@modelprofile.com/flexharness 9.10.0 → 10.1.0

package/dist_ts/utils.storerules.js

@@ -0,0 +1,107 @@
+import { FlexHarnessStoreConflictError, FlexHarnessStoreFormatError, FlexHarnessValidationError, } from './errors.js';
+import { assertJsonSerializable, cloneSerializable } from './utils.json.js';
+import { assertExactKeys, assertRecord } from './utils.storecodecs.js';
+export function validateIdentifier(value, name) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new FlexHarnessValidationError(`${name} must be a non-empty string.`);
+    }
+}
+export function validateExpectedRevision(expectedRevision) {
+    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+        throw new FlexHarnessValidationError('expectedRevision must be a non-negative integer.');
+    }
+}
+export function validateProjectManagementWriteContext(writeContext) {
+    assertJsonSerializable(writeContext, '$writeContext');
+    assertRecord(writeContext, 'writeContext');
+    assertExactKeys(writeContext, ['actor', 'runId', 'agent', 'toolCallId'], 'writeContext');
+    if (writeContext.actor !== 'agent' && writeContext.actor !== 'application') {
+        throw new FlexHarnessValidationError('writeContext.actor must be agent or application.');
+    }
+    for (const key of ['runId', 'agent', 'toolCallId']) {
+        if (writeContext[key] !== undefined)
+            validateIdentifier(writeContext[key], `writeContext.${key}`);
+    }
+}
+export function validateSnapshotSave(snapshot, expectedRevision, validator) {
+    validator(snapshot);
+    validateExpectedRevision(expectedRevision);
+    if (snapshot.revision !== expectedRevision + 1) {
+        throw new FlexHarnessStoreFormatError(`Snapshot revision ${snapshot.revision} must equal expected revision ${expectedRevision} plus one.`);
+    }
+    return cloneSerializable(snapshot);
+}
+export function providerKey(storageKey, sessionId) {
+    validateIdentifier(storageKey, 'storageKey');
+    validateIdentifier(sessionId, 'sessionId');
+    return JSON.stringify([storageKey, sessionId]);
+}
+export function assertProjectionSession(snapshot, sessionId) {
+    for (const message of snapshot.messages) {
+        if (message.sessionId !== sessionId) {
+            throw new FlexHarnessStoreFormatError(`Projection message "${message.messageId}" does not belong to session "${sessionId}".`);
+        }
+    }
+    for (const terminal of snapshot.stagedTerminals) {
+        if (terminal.userMessage.sessionId !== sessionId
+            || terminal.assistantMessage.sessionId !== sessionId) {
+            throw new FlexHarnessStoreFormatError(`Staged terminal "${terminal.runId}" does not belong to session "${sessionId}".`);
+        }
+    }
+}
+function sameProjectManagementGeneration(left, right) {
+    return left.sessionGenerationId === right.sessionGenerationId
+        && left.sessionGenerationSequence === right.sessionGenerationSequence;
+}
+function canInitializeProjectManagementGeneration(current, next, expectedRevision) {
+    return 'deletedAt' in current
+        && expectedRevision === 0
+        && next.sessionGenerationId !== current.sessionGenerationId
+        && next.sessionGenerationSequence > current.sessionGenerationSequence;
+}
+/**
+ * Admits a live project-management save over the stored record: a CAS save within the stored
+ * generation, or a newer generation that replaces a tombstone at expected revision 0.
+ */
+export function assertProjectManagementSaveAdmitted(key, current, snapshot, expectedRevision) {
+    const actualRevision = current?.revision ?? 0;
+    if (current && !sameProjectManagementGeneration(current, snapshot)) {
+        if (!canInitializeProjectManagementGeneration(current, snapshot, expectedRevision)) {
+            throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+        }
+    }
+    else if ((current && 'deletedAt' in current) || actualRevision !== expectedRevision) {
+        throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+    }
+}
+/**
+ * Admits a project-management tombstone over the stored record. Returns false when the same
+ * generation is already tombstoned, which makes a repeated cleanup idempotent.
+ */
+export function isProjectManagementTombstoneAdmitted(key, current, tombstone, expectedRevision) {
+    const actualRevision = current?.revision ?? 0;
+    if (current && sameProjectManagementGeneration(current, tombstone)) {
+        if ('deletedAt' in current)
+            return false;
+        if (actualRevision !== expectedRevision) {
+            throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+        }
+    }
+    else if (current) {
+        if (!canInitializeProjectManagementGeneration(current, tombstone, expectedRevision)) {
+            throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+        }
+    }
+    else if (actualRevision !== expectedRevision) {
+        throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+    }
+    return true;
+}
+/** An archive is written once; repeating it with the same events is a no-op. */
+export function assertSameArchiveEvents(existing, next) {
+    if (JSON.stringify(existing.events.map((event) => event.id))
+        !== JSON.stringify(next.events.map((event) => event.id))) {
+        throw new Error(`Archive "${next.archiveId}" already exists with different events.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_chat_harness/classes.transcript.d.ts

@@ -0,0 +1,88 @@
+import type * as plugins from './plugins.js';
+import type { IFlexMessage, IFlexPermissionRequest, IFlexProjectStateResult, IFlexSession, TFlexHarnessEvent } from '../dist_ts/interfaces.js';
+export interface IFlexHarnessTranscriptOptions {
+    scopeId: string;
+    sessionId: string;
+}
+/** What `load()` reads: the session's authoritative state, as the harness APIs return it. */
+export interface IFlexHarnessTranscriptSnapshot {
+    /** `getMessages()` of the session. */
+    messages: readonly IFlexMessage[];
+    /** `listPendingPermissions()` of the session. */
+    permissions?: readonly IFlexPermissionRequest[];
+    /** `getSession()`; states whether a run is active or failed. */
+    session?: IFlexSession;
+    /** `getProjectState()`, when project management is enabled. */
+    project?: IFlexProjectStateResult;
+}
+/** The inputs of `dees-harness-chat`, as plain data the transcript does not share. */
+export interface IFlexHarnessTranscriptView {
+    messages: plugins.IHarnessMessage[];
+    permissions: plugins.IHarnessPermissionRequest[];
+    /** FlexHarness asks no questions; always empty. */
+    questions: plugins.IHarnessQuestionRequest[];
+    status: plugins.IHarnessStatus;
+    usage: plugins.IHarnessUsage;
+    todos: plugins.IHarnessTodoItem[];
+    scratchpad?: plugins.IHarnessScratchpad;
+}
+/** Where an event stands in its harness instance's event stream, as the host received it. */
+export interface IFlexHarnessEventDelivery {
+    /**
+     * The `sequence` of the event of the same harness instance the host received just before this
+     * one, of any session; `undefined` for the first event after `load()`. The host forwards every
+     * event of the instance in order, and calls `load()` after a gap or a reconnect.
+     */
+    precedingSequence: number | undefined;
+}
+/**
+ * What one event changed. Apply `deltas` with `applyDelta()` in order; when `messages` is true,
+ * assign `transcript.view().messages` instead, which already holds the deltas. `reload` means
+ * the transcript can no longer follow the session incrementally: read the session again and
+ * pass it to `load()`.
+ */
+export interface IFlexHarnessTranscriptChange {
+    messages: boolean;
+    deltas: plugins.THarnessStreamDelta[];
+    permissions: boolean;
+    status: boolean;
+    usage: boolean;
+    reload: boolean;
+}
+/**
+ * Follows one FlexHarness session and keeps the `dees-harness-chat` inputs for it. It is a pure
+ * reducer over the session's public messages and events: it imports no runtime code, so it runs
+ * in the browser beside the components as well as on the server beside the harness.
+ */
+export declare class FlexHarnessTranscript {
+    readonly scopeId: string;
+    readonly sessionId: string;
+    private flexMessages;
+    private readonly timings;
+    private readonly partBytes;
+    private readonly permissionRows;
+    private status;
+    private usage;
+    private todos;
+    private scratchpad?;
+    private runningQueueId?;
+    constructor(options: IFlexHarnessTranscriptOptions);
+    /** The queue entry whose run is running; a steer joins it. */
+    get activeQueueId(): string | undefined;
+    /** Replaces everything with the session's authoritative state. */
+    load(snapshot: IFlexHarnessTranscriptSnapshot): void;
+    /** Takes in the session's task list and scratchpad after `getProjectState()`. */
+    applyProjectState(project: IFlexProjectStateResult): void;
+    /** A copy of the component inputs; the transcript keeps its own objects. */
+    view(): IFlexHarnessTranscriptView;
+    /**
+     * Takes one event of the harness instance. An event that does not directly follow
+     * `delivery.precedingSequence` means events were lost, possibly of this session, so the change
+     * asks for a reload.
+     */
+    applyEvent(event: TFlexHarnessEvent, delivery: IFlexHarnessEventDelivery): IFlexHarnessTranscriptChange;
+    private setStatus;
+    private upsertMessage;
+    private applyPartSnapshot;
+    private applyPartDelta;
+}

package/dist_ts_chat_harness/classes.transcript.js

@@ -0,0 +1,268 @@
+import { flexMessageToHarnessRows, flexPartRowId, flexPartTimingKey, flexPermissionToHarness, flexProjectToHarnessScratchpad, flexProjectToHarnessTodos, flexSessionToHarnessStatus, flexToolPartToHarness, flexUsageToHarness, } from './functions.mapping.js';
+const utf8 = new TextEncoder();
+/** UTF-8 bytes `delta` adds to `text`, counted the way FlexHarness counts them. */
+function appendedUtf8Bytes(text, delta) {
+    const trailing = text.charCodeAt(text.length - 1);
+    const leading = delta.charCodeAt(0);
+    const joinsSurrogatePair = trailing >= 0xd800 && trailing <= 0xdbff
+        && leading >= 0xdc00 && leading <= 0xdfff;
+    return utf8.encode(delta).length - (joinsSurrogatePair ? 2 : 0);
+}
+function sumUsage(total, usage) {
+    const sum = (key) => (total[key] ?? 0) + (usage[key] ?? 0);
+    return {
+        inputTokens: sum('inputTokens'),
+        outputTokens: sum('outputTokens'),
+        totalTokens: sum('totalTokens'),
+        cacheReadTokens: sum('cacheReadTokens'),
+        cacheWriteTokens: sum('cacheWriteTokens'),
+    };
+}
+const noChange = () => ({
+    messages: false,
+    deltas: [],
+    permissions: false,
+    status: false,
+    usage: false,
+    reload: false,
+});
+/**
+ * Follows one FlexHarness session and keeps the `dees-harness-chat` inputs for it. It is a pure
+ * reducer over the session's public messages and events: it imports no runtime code, so it runs
+ * in the browser beside the components as well as on the server beside the harness.
+ */
+export class FlexHarnessTranscript {
+    scopeId;
+    sessionId;
+    flexMessages = [];
+    timings = new Map();
+    partBytes = new Map();
+    permissionRows = new Map();
+    status = { type: 'idle' };
+    usage = {};
+    todos = [];
+    scratchpad;
+    runningQueueId;
+    constructor(options) {
+        this.scopeId = options.scopeId;
+        this.sessionId = options.sessionId;
+    }
+    /** The queue entry whose run is running; a steer joins it. */
+    get activeQueueId() {
+        return this.runningQueueId;
+    }
+    /** Replaces everything with the session's authoritative state. */
+    load(snapshot) {
+        this.flexMessages = [];
+        this.todos = [];
+        this.scratchpad = undefined;
+        this.runningQueueId = undefined;
+        this.timings.clear();
+        this.partBytes.clear();
+        for (const message of snapshot.messages)
+            this.upsertMessage(message);
+        this.permissionRows.clear();
+        for (const request of snapshot.permissions ?? []) {
+            this.permissionRows.set(request.permissionId, flexPermissionToHarness(request));
+        }
+        this.status = snapshot.session ? flexSessionToHarnessStatus(snapshot.session) : { type: 'idle' };
+        this.usage = this.flexMessages.reduce((total, message) => message.usage ? sumUsage(total, flexUsageToHarness(message.usage)) : total, {});
+        if (snapshot.project)
+            this.applyProjectState(snapshot.project);
+    }
+    /** Takes in the session's task list and scratchpad after `getProjectState()`. */
+    applyProjectState(project) {
+        this.todos = flexProjectToHarnessTodos(project);
+        this.scratchpad = flexProjectToHarnessScratchpad(this.sessionId, project);
+    }
+    /** A copy of the component inputs; the transcript keeps its own objects. */
+    view() {
+        return structuredClone({
+            messages: this.flexMessages.flatMap((message, index) => flexMessageToHarnessRows(message, index, this.timings)),
+            permissions: [...this.permissionRows.values()],
+            questions: [],
+            status: this.status,
+            usage: this.usage,
+            todos: this.todos,
+            ...(this.scratchpad === undefined ? {} : { scratchpad: this.scratchpad }),
+        });
+    }
+    /**
+     * Takes one event of the harness instance. An event that does not directly follow
+     * `delivery.precedingSequence` means events were lost, possibly of this session, so the change
+     * asks for a reload.
+     */
+    applyEvent(event, delivery) {
+        const change = noChange();
+        if (delivery.precedingSequence !== undefined
+            && event.sequence !== delivery.precedingSequence + 1) {
+            change.reload = true;
+            return change;
+        }
+        if (event.scopeId !== this.scopeId || event.sessionId !== this.sessionId)
+            return change;
+        const timestamp = Date.parse(event.timestamp);
+        switch (event.type) {
+            case 'session.created':
+            case 'session.updated':
+                this.setStatus(change, flexSessionToHarnessStatus(event.session));
+                break;
+            case 'session.deleted':
+                this.load({ messages: [] });
+                change.messages = change.permissions = change.status = change.usage = true;
+                break;
+            case 'run.started':
+                this.setStatus(change, { type: 'busy' });
+                break;
+            case 'message.created':
+            case 'message.updated':
+                this.upsertMessage(event.message);
+                change.messages = true;
+                break;
+            case 'part.started':
+                this.timings.set(flexPartTimingKey(event.messageId, event.partId), { startedAt: timestamp });
+                this.applyPartSnapshot(change, event.messageId, event.partIndex, event.part);
+                break;
+            case 'part.updated':
+                this.applyPartSnapshot(change, event.messageId, event.partIndex, event.part);
+                break;
+            case 'part.completed': {
+                const key = flexPartTimingKey(event.messageId, event.partId);
+                this.timings.set(key, { ...this.timings.get(key), endedAt: timestamp });
+                this.applyPartSnapshot(change, event.messageId, event.partIndex, event.part);
+                break;
+            }
+            case 'part.delta':
+                this.applyPartDelta(change, event);
+                break;
+            case 'permission.requested':
+                this.permissionRows.set(event.request.permissionId, flexPermissionToHarness(event.request));
+                change.permissions = true;
+                break;
+            case 'permission.resolved': {
+                const row = this.permissionRows.get(event.request.permissionId);
+                if (!row)
+                    break;
+                row.response = event.decision;
+                row.respondedAt = timestamp;
+                change.permissions = true;
+                break;
+            }
+            case 'run.finished':
+                this.upsertMessage(event.message);
+                change.messages = true;
+                if (event.message.usage) {
+                    this.usage = sumUsage(this.usage, flexUsageToHarness(event.message.usage));
+                    change.usage = true;
+                }
+                this.setStatus(change, event.status === 'failed'
+                    ? { type: 'error', ...(event.error ? { message: event.error.message } : {}) }
+                    : { type: 'idle' });
+                break;
+            case 'prompt.started':
+            case 'prompt.running':
+                this.runningQueueId = event.queueId;
+                break;
+            case 'prompt.finished':
+                if (this.runningQueueId === event.queueId)
+                    this.runningQueueId = undefined;
+                break;
+            case 'session.history.changed':
+                change.reload = true;
+                break;
+            default:
+                break;
+        }
+        return change;
+    }
+    setStatus(change, status) {
+        if (status.type === this.status.type && status.message === this.status.message)
+            return;
+        this.status = status;
+        change.status = true;
+    }
+    upsertMessage(message) {
+        const index = this.flexMessages.findIndex((entry) => entry.messageId === message.messageId);
+        const copy = structuredClone(message);
+        if (index === -1)
+            this.flexMessages.push(copy);
+        else
+            this.flexMessages[index] = copy;
+        for (const part of copy.parts) {
+            if (part.type === 'text' || part.type === 'reasoning') {
+                this.partBytes.set(flexPartTimingKey(copy.messageId, part.partId), utf8.encode(part.text).length);
+            }
+        }
+    }
+    applyPartSnapshot(change, messageId, partIndex, part) {
+        const message = this.flexMessages.find((entry) => entry.messageId === messageId);
+        if (!message || partIndex > message.parts.length) {
+            change.reload = true;
+            return;
+        }
+        const previous = message.parts[partIndex];
+        message.parts[partIndex] = structuredClone(part);
+        const key = flexPartTimingKey(messageId, part.partId);
+        if (part.type === 'text' || part.type === 'reasoning') {
+            this.partBytes.set(key, utf8.encode(part.text).length);
+        }
+        const rowId = flexPartRowId(messageId, part.partId);
+        if (previous?.partId !== part.partId || previous.type !== part.type) {
+            change.messages = true;
+            return;
+        }
+        if (part.type === 'tool') {
+            change.deltas.push({
+                type: 'tool-update',
+                messageId: rowId,
+                tool: flexToolPartToHarness(part, this.timings.get(key)),
+            });
+        }
+        else if (part.type === 'text' && previous.type === 'text') {
+            if (previous.text !== part.text)
+                change.messages = true;
+            else if (message.status !== 'streaming' || partIndex !== message.parts.length - 1) {
+                change.deltas.push({ type: 'message-end', messageId: rowId });
+            }
+        }
+        else if (part.type === 'reasoning' && previous.type === 'reasoning') {
+            if (previous.text !== part.text)
+                change.messages = true;
+            else if (part.status !== 'running') {
+                change.deltas.push({
+                    type: 'reasoning-end',
+                    messageId: rowId,
+                    partId: part.partId,
+                    endedAt: this.timings.get(key)?.endedAt,
+                });
+            }
+        }
+        else {
+            change.messages = true;
+        }
+    }
+    applyPartDelta(change, event) {
+        const message = this.flexMessages.find((entry) => entry.messageId === event.messageId);
+        const part = message?.parts[event.partIndex];
+        const key = flexPartTimingKey(event.messageId, event.partId);
+        if (!part
+            || part.partId !== event.partId
+            || part.type !== event.partType
+            || this.partBytes.get(key) !== event.baseTextUtf8Bytes) {
+            change.reload = true;
+            return;
+        }
+        const bytes = event.baseTextUtf8Bytes + appendedUtf8Bytes(part.text, event.delta);
+        if (bytes !== event.textUtf8Bytes) {
+            change.reload = true;
+            return;
+        }
+        part.text += event.delta;
+        this.partBytes.set(key, bytes);
+        const rowId = flexPartRowId(event.messageId, event.partId);
+        change.deltas.push(event.partType === 'text'
+            ? { type: 'text', messageId: rowId, delta: event.delta }
+            : { type: 'reasoning', messageId: rowId, partId: event.partId, delta: event.delta });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.transcript.js","sourceRoot":"","sources":["../../ts_chat_harness/classes.transcript.ts"],"names":[],"mappings":"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"}

package/dist_ts_chat_harness/functions.intents.d.ts

@@ -0,0 +1,62 @@
+import type * as plugins from './plugins.js';
+import type { FlexHarness } from '../dist_ts/classes.flexharness.js';
+import type { IFlexPromptOptions, IFlexPromptQueueAdmission, TFlexPermissionDecision, TFlexPromptPart } from '../dist_ts/interfaces.js';
+/** The session a chat view shows. */
+export interface IFlexHarnessChatTarget {
+    scopeId: string;
+    sessionId: string;
+}
+/**
+ * One call a chat view asks the harness to make, as plain data a host can carry from the browser
+ * to the server that owns the harness.
+ */
+export type TFlexHarnessChatIntent = (IFlexHarnessChatTarget & {
+    type: 'enqueuePrompt';
+    prompt: TFlexPromptPart[];
+    options: IFlexPromptOptions;
+}) | (IFlexHarnessChatTarget & {
+    type: 'steerPrompt';
+    queueId: string;
+    steerId: string;
+    prompt: TFlexPromptPart[];
+    options: IFlexPromptOptions;
+}) | (IFlexHarnessChatTarget & {
+    type: 'respondToPermission';
+    permissionId: string;
+    decision: TFlexPermissionDecision;
+}) | (IFlexHarnessChatTarget & {
+    type: 'abort';
+});
+export interface IFlexHarnessSendIntentOptions {
+    /** The running queue entry, `FlexHarnessTranscript.activeQueueId`; a steer joins it. */
+    activeQueueId?: string;
+    /**
+     * The model hint the prompt carries. Defaults to the composer's `model`. A host that offers
+     * accounts or reasoning efforts encodes them in its own hint scheme here.
+     */
+    modelHint?: string;
+}
+/**
+ * Maps `harness-send`. A message sent while idle, or queued behind the running turn, becomes a
+ * queued prompt. A steer joins the running turn; with no running turn it is the next turn's
+ * input, so it is queued as well. A steer keeps the prompt options for that case only: it answers
+ * on the running turn's model. A steer id comes from `crypto.randomUUID()`, which browsers offer
+ * in secure contexts only (HTTPS or localhost).
+ */
+export declare function flexHarnessSendIntent(target: IFlexHarnessChatTarget, detail: plugins.IHarnessComposerSendDetail, options?: IFlexHarnessSendIntentOptions): TFlexHarnessChatIntent;
+/**
+ * Maps `harness-permission-response`. The card reports a remembered approval as `remember`,
+ * which FlexHarness calls `always`.
+ */
+export declare function flexHarnessPermissionIntent(target: IFlexHarnessChatTarget, detail: plugins.IHarnessPermissionResponseDetail): TFlexHarnessChatIntent;
+/** Maps `harness-abort`. */
+export declare function flexHarnessAbortIntent(target: IFlexHarnessChatTarget): TFlexHarnessChatIntent;
+/** The harness calls `runFlexHarnessChatIntent` makes. */
+export type TFlexHarnessChatHost = Pick<FlexHarness<unknown>, 'enqueuePrompt' | 'steerPrompt' | 'respondToPermission' | 'abort'>;
+/**
+ * Makes the call an intent names, on the server that owns the harness, once the harness admitted
+ * it. A queued prompt returns its admission: its `completion` settles when the run ends, and the
+ * caller owns it, as with `enqueuePrompt()`. A steer whose turn ended before the harness took it
+ * is the next turn's input, so it is queued instead and returns that admission.
+ */
+export declare function runFlexHarnessChatIntent(harness: TFlexHarnessChatHost, intent: TFlexHarnessChatIntent): Promise<IFlexPromptQueueAdmission | undefined>;