@modelprofile.com/flexharness 10.17.1 → 10.19.0

package/dist_ts_chat_harness_server/classes.sessionlists.d.ts

@@ -0,0 +1,21 @@
+import type * as plugins from './plugins.js';
+import type { IFlexHarnessChatCaller, IFlexHarnessChatPeers } from './interfaces.js';
+type TSessionEvent = plugins.IFlexSessionCreatedEvent | plugins.IFlexSessionUpdatedEvent | plugins.IFlexSessionDeletedEvent;
+/**
+ * The conversation lists of the attached tabs: a conversation created, changed or deleted in a
+ * tab's scope reaches the tab as a push. Pushes are best effort; a tab that misses one attaches
+ * again after it reconnects and gets the whole list.
+ */
+export declare class FlexHarnessChatSessionLists {
+    private readonly peers;
+    private readonly toSessionMeta;
+    private readonly attached;
+    constructor(peersArg: IFlexHarnessChatPeers, toSessionMetaArg: (sessionArg: plugins.IFlexSession) => plugins.IHarnessSessionMeta);
+    get tabs(): IFlexHarnessChatCaller[];
+    attach(tabArg: IFlexHarnessChatCaller): void;
+    forget(tabArg: IFlexHarnessChatCaller): void;
+    clear(): void;
+    publish(eventArg: TSessionEvent): void;
+    private pump;
+}
+export {};

package/dist_ts_chat_harness_server/classes.sessionlists.js

@@ -0,0 +1,70 @@
+import { tabKey } from './functions.validation.js';
+/**
+ * The conversation lists of the attached tabs: a conversation created, changed or deleted in a
+ * tab's scope reaches the tab as a push. Pushes are best effort; a tab that misses one attaches
+ * again after it reconnects and gets the whole list.
+ */
+export class FlexHarnessChatSessionLists {
+    peers;
+    toSessionMeta;
+    attached = new Map();
+    constructor(peersArg, toSessionMetaArg) {
+        this.peers = peersArg;
+        this.toSessionMeta = toSessionMetaArg;
+    }
+    get tabs() {
+        return [...this.attached.values()].map((entry) => entry.tab);
+    }
+    attach(tabArg) {
+        this.attached.set(tabKey(tabArg), {
+            tab: { tabId: tabArg.tabId, scopeId: tabArg.scopeId },
+            upserts: new Map(),
+            deletedIds: new Set(),
+            sending: false,
+        });
+    }
+    forget(tabArg) {
+        this.attached.delete(tabKey(tabArg));
+    }
+    clear() {
+        this.attached.clear();
+    }
+    publish(eventArg) {
+        for (const [key, entry] of this.attached) {
+            if (entry.tab.scopeId !== eventArg.scopeId)
+                continue;
+            if (eventArg.type === 'session.deleted') {
+                entry.upserts.delete(eventArg.sessionId);
+                entry.deletedIds.add(eventArg.sessionId);
+            }
+            else {
+                entry.deletedIds.delete(eventArg.sessionId);
+                entry.upserts.set(eventArg.sessionId, this.toSessionMeta(eventArg.session));
+            }
+            void this.pump(key, entry);
+        }
+    }
+    async pump(keyArg, entryArg) {
+        if (entryArg.sending)
+            return;
+        entryArg.sending = true;
+        try {
+            while (entryArg.upserts.size || entryArg.deletedIds.size) {
+                const peer = await this.peers.find(entryArg.tab).catch(() => null);
+                if (!peer) {
+                    if (this.attached.get(keyArg) === entryArg)
+                        this.attached.delete(keyArg);
+                    return;
+                }
+                const push = { upserts: [...entryArg.upserts.values()], deletedIds: [...entryArg.deletedIds] };
+                entryArg.upserts.clear();
+                entryArg.deletedIds.clear();
+                await peer.sessions(push).catch(() => undefined);
+            }
+        }
+        finally {
+            entryArg.sending = false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_chat_harness_server/classes.turngate.d.ts

@@ -0,0 +1,38 @@
+import * as plugins from './plugins.js';
+import type { IFlexHarnessChatCaller, IFlexHarnessChatLimits, IFlexHarnessChatTurn } from './interfaces.js';
+/** The harness calls the gate makes. */
+export type TFlexHarnessChatGateHarness = Pick<plugins.FlexHarness<unknown>, 'enqueuePrompt' | 'steerPrompt' | 'getPromptQueueEntry' | 'cancelPrompt'>;
+/**
+ * Admits messages: one turn per conversation, bound to the tab that started it and the context it
+ * was sent with, since FlexHarness carries no per-prompt context. A message sent while a turn runs
+ * steers it; a steer the turn no longer takes waits for the ending turn and starts the next one.
+ */
+export declare class FlexHarnessChatTurnGate<TContext> {
+    private readonly harness;
+    private readonly limits;
+    private readonly bindings;
+    /** serializes the admission of messages per conversation */
+    private readonly locks;
+    /** the admissions under way, each settling once its message was admitted or refused */
+    private readonly admissions;
+    private stopped;
+    constructor(harnessArg: TFlexHarnessChatGateHarness, limitsArg: IFlexHarnessChatLimits);
+    turnOf(scopeIdArg: string, sessionIdArg: string): IFlexHarnessChatTurn<TContext> | undefined;
+    /** Whether a turn the tab started still runs. */
+    hasTurnOf(tabArg: IFlexHarnessChatCaller): boolean;
+    /** Takes one harness event: a prompt that runs now takes steers. */
+    takeEvent(eventArg: plugins.TFlexHarnessEvent): void;
+    /** Admits a message under the conversation's lock; every wait ends at the deadline. */
+    admit(callerArg: IFlexHarnessChatCaller, sessionIdArg: string, sendArg: plugins.IHarnessComposerSendDetail, contextArg: TContext, deadlineArg: number): Promise<plugins.TFlexHarnessChatResponse<'flexHarnessChatSend'>>;
+    /**
+     * Refuses new messages, stops every turn this gate started, also those admitted while it stops,
+     * and waits until the admissions under way were refused and every turn ended.
+     */
+    stop(): Promise<void>;
+    private cancelTurns;
+    private cancel;
+    private assertOpen;
+    private withLock;
+    private admitLocked;
+    private startTurn;
+}

package/dist_ts_chat_harness_server/classes.turngate.js

@@ -0,0 +1,207 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessChatRequestError } from './errors.js';
+import { STOPPED_MESSAGE } from './functions.validation.js';
+const STILL_FINISHING_MESSAGE = 'The assistant is still finishing its previous reply. Send your message again in a moment.';
+const bindingKey = (scopeIdArg, sessionIdArg) => `${scopeIdArg}\n${sessionIdArg}`;
+/** Whether the promise settled before the deadline (a time in ms since the epoch). */
+const settlesBefore = async (promiseArg, deadlineArg) => {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), Math.max(0, deadlineArg - Date.now()));
+    });
+    try {
+        return await Promise.race([promiseArg.then(() => true, () => true), expired]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+/**
+ * Admits messages: one turn per conversation, bound to the tab that started it and the context it
+ * was sent with, since FlexHarness carries no per-prompt context. A message sent while a turn runs
+ * steers it; a steer the turn no longer takes waits for the ending turn and starts the next one.
+ */
+export class FlexHarnessChatTurnGate {
+    harness;
+    limits;
+    bindings = new Map();
+    /** serializes the admission of messages per conversation */
+    locks = new Map();
+    /** the admissions under way, each settling once its message was admitted or refused */
+    admissions = new Set();
+    stopped = false;
+    constructor(harnessArg, limitsArg) {
+        this.harness = harnessArg;
+        this.limits = limitsArg;
+    }
+    turnOf(scopeIdArg, sessionIdArg) {
+        const binding = this.bindings.get(bindingKey(scopeIdArg, sessionIdArg));
+        return binding
+            ? { scopeId: binding.scopeId, sessionId: binding.sessionId, tabId: binding.tabId, context: binding.context }
+            : undefined;
+    }
+    /** Whether a turn the tab started still runs. */
+    hasTurnOf(tabArg) {
+        for (const binding of this.bindings.values()) {
+            if (binding.tabId === tabArg.tabId && binding.scopeId === tabArg.scopeId)
+                return true;
+        }
+        return false;
+    }
+    /** Takes one harness event: a prompt that runs now takes steers. */
+    takeEvent(eventArg) {
+        if (eventArg.type !== 'prompt.running' && eventArg.type !== 'prompt.finished')
+            return;
+        const binding = this.bindings.get(bindingKey(eventArg.scopeId, eventArg.sessionId));
+        if (binding && binding.queueId === eventArg.queueId)
+            binding.markRunning();
+    }
+    /** Admits a message under the conversation's lock; every wait ends at the deadline. */
+    admit(callerArg, sessionIdArg, sendArg, contextArg, deadlineArg) {
+        if (this.stopped)
+            return Promise.reject(new FlexHarnessChatRequestError(STOPPED_MESSAGE));
+        const admission = this.withLock(bindingKey(callerArg.scopeId, sessionIdArg), () => this.admitLocked(callerArg, sessionIdArg, sendArg, contextArg, deadlineArg));
+        const settled = admission.then(() => undefined, () => undefined);
+        this.admissions.add(settled);
+        void settled.then(() => this.admissions.delete(settled));
+        return admission;
+    }
+    /**
+     * Refuses new messages, stops every turn this gate started, also those admitted while it stops,
+     * and waits until the admissions under way were refused and every turn ended.
+     */
+    async stop() {
+        this.stopped = true;
+        this.cancelTurns();
+        await Promise.all([...this.admissions]);
+        // a turn whose prompt was being queued when the gate stopped was cancelled by its admission
+        this.cancelTurns();
+        await Promise.all([...this.bindings.values()].map((binding) => binding.settled));
+    }
+    cancelTurns() {
+        for (const binding of this.bindings.values()) {
+            clearTimeout(binding.timer);
+            if (binding.queueId)
+                this.cancel(binding.scopeId, binding.sessionId, binding.queueId);
+        }
+    }
+    cancel(scopeIdArg, sessionIdArg, queueIdArg) {
+        void this.harness.cancelPrompt(scopeIdArg, sessionIdArg, queueIdArg).catch(() => false);
+    }
+    assertOpen() {
+        if (this.stopped)
+            throw new FlexHarnessChatRequestError(STOPPED_MESSAGE);
+    }
+    async withLock(keyArg, fnArg) {
+        const previous = this.locks.get(keyArg) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => (release = resolve));
+        const chained = previous.then(() => current);
+        this.locks.set(keyArg, chained);
+        await previous;
+        try {
+            return await fnArg();
+        }
+        finally {
+            release();
+            if (this.locks.get(keyArg) === chained)
+                this.locks.delete(keyArg);
+        }
+    }
+    async admitLocked(callerArg, sessionIdArg, sendArg, contextArg, deadlineArg) {
+        const waitFor = async (promiseArg) => {
+            if (!(await settlesBefore(promiseArg, deadlineArg)))
+                throw new FlexHarnessChatRequestError(STILL_FINISHING_MESSAGE);
+        };
+        this.assertOpen();
+        const target = { scopeId: callerArg.scopeId, sessionId: sessionIdArg };
+        const binding = this.bindings.get(bindingKey(target.scopeId, target.sessionId));
+        if (binding?.queueId) {
+            for (let attempt = 0; attempt < 2; attempt++) {
+                const intent = intentOf(target, { ...sendArg, delivery: 'steer' }, binding.queueId);
+                if (intent.type !== 'steerPrompt')
+                    break;
+                this.assertOpen();
+                try {
+                    await this.harness.steerPrompt(target.scopeId, target.sessionId, intent.queueId, {
+                        steerId: intent.steerId,
+                        prompt: intent.prompt,
+                    });
+                    return { sessionId: sessionIdArg, steerId: intent.steerId };
+                }
+                catch (error) {
+                    if (!(error instanceof plugins.FlexHarnessSteerRejectedError) || error.reason !== 'not-running')
+                        throw error;
+                }
+                // a prompt still waiting for its run takes steers once it runs
+                const entry = await this.harness
+                    .getPromptQueueEntry(target.scopeId, target.sessionId, binding.queueId)
+                    .catch(() => undefined);
+                if (!entry || !['queued', 'starting', 'scheduled'].includes(entry.status))
+                    break;
+                await waitFor(Promise.race([binding.running, binding.settled]));
+            }
+            await waitFor(binding.settled);
+        }
+        else if (binding) {
+            await waitFor(binding.settled);
+        }
+        this.assertOpen();
+        return this.startTurn(callerArg, sessionIdArg, sendArg, contextArg);
+    }
+    async startTurn(callerArg, sessionIdArg, sendArg, contextArg) {
+        const key = bindingKey(callerArg.scopeId, sessionIdArg);
+        const intent = intentOf({ scopeId: callerArg.scopeId, sessionId: sessionIdArg }, { ...sendArg, delivery: 'turn' });
+        if (intent.type !== 'enqueuePrompt')
+            throw new Error('A new turn must be queued.');
+        let markSettled;
+        let markRunning;
+        const binding = {
+            scopeId: callerArg.scopeId,
+            sessionId: sessionIdArg,
+            tabId: callerArg.tabId,
+            context: contextArg,
+            running: new Promise((resolve) => (markRunning = resolve)),
+            markRunning: () => markRunning(),
+            settled: new Promise((resolve) => (markSettled = resolve)),
+        };
+        const end = () => {
+            clearTimeout(binding.timer);
+            if (this.bindings.get(key) === binding)
+                this.bindings.delete(key);
+            markRunning();
+            markSettled();
+        };
+        // bound before the prompt is queued: the model resolver may run at once
+        this.bindings.set(key, binding);
+        let queued;
+        try {
+            queued = await this.harness.enqueuePrompt(callerArg.scopeId, sessionIdArg, intent.prompt);
+        }
+        catch (error) {
+            end();
+            throw error;
+        }
+        binding.queueId = queued.queueId;
+        // the outcome of a turn is in its conversation; a failed turn is not an error of this request
+        void queued.completion.then(() => undefined, () => undefined).finally(end);
+        if (this.stopped) {
+            // the gate stopped while the prompt was being queued: the turn never runs on
+            this.cancel(callerArg.scopeId, sessionIdArg, queued.queueId);
+            throw new FlexHarnessChatRequestError(STOPPED_MESSAGE);
+        }
+        binding.timer = setTimeout(() => this.cancel(callerArg.scopeId, sessionIdArg, queued.queueId), this.limits.turnTimeoutMs);
+        binding.timer.unref?.();
+        return { sessionId: sessionIdArg, queueId: queued.queueId };
+    }
+}
+/** The harness call a composer message becomes; an attachment the composer could not read whole is refused. */
+const intentOf = (targetArg, sendArg, activeQueueIdArg) => {
+    try {
+        return plugins.flexHarnessSendIntent(targetArg, sendArg, activeQueueIdArg ? { activeQueueId: activeQueueIdArg } : {});
+    }
+    catch (error) {
+        throw new FlexHarnessChatRequestError(error?.message || 'The message could not be read.');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.turngate.js","sourceRoot":"","sources":["../ts_chat_harness_server/classes.turngate.ts"],"names":[],"mappings":"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"}

package/dist_ts_chat_harness_server/errors.d.ts

@@ -0,0 +1,5 @@
+export { FlexHarnessChatRequestError } from './plugins.js';
+/** The tab of a turn is gone or did not answer a tool call in time. */
+export declare class FlexHarnessChatTabUnavailableError extends Error {
+    constructor(options?: ErrorOptions);
+}

package/dist_ts_chat_harness_server/errors.js

@@ -0,0 +1,9 @@
+export { FlexHarnessChatRequestError } from './plugins.js';
+/** The tab of a turn is gone or did not answer a tool call in time. */
+export class FlexHarnessChatTabUnavailableError extends Error {
+    constructor(options) {
+        super('The tab that started this turn is closed, lost its connection or did not answer in time.', options);
+        this.name = 'FlexHarnessChatTabUnavailableError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfY2hhdF9oYXJuZXNzX3NlcnZlci9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRTNELHVFQUF1RTtBQUN2RSxNQUFNLE9BQU8sa0NBQW1DLFNBQVEsS0FBSztJQUMzRCxZQUFZLE9BQXNCO1FBQ2hDLEtBQUssQ0FBQywwRkFBMEYsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUMzRyxJQUFJLENBQUMsSUFBSSxHQUFHLG9DQUFvQyxDQUFDO0lBQ25ELENBQUM7Q0FDRiJ9

package/dist_ts_chat_harness_server/functions.errorprojector.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+export interface IFlexHarnessChatErrorProjectorOptions {
+    /** The host's own projection, tried first; return `undefined` for errors it does not know. */
+    project?: (error: unknown, context: plugins.IFlexExternalErrorContext) => plugins.IFlexErrorInfo | undefined;
+}
+/**
+ * An `externalErrorProjector` for chat conversations: what a failed model call, tool or resolver
+ * shows in the conversation, never a provider's response text. The host's projection comes first;
+ * then a tab that is gone, a model limit, an HTTP status of the model provider, and a fixed message.
+ */
+export declare function createFlexHarnessChatErrorProjector(options?: IFlexHarnessChatErrorProjectorOptions): plugins.TFlexExternalErrorProjector;

package/dist_ts_chat_harness_server/functions.errorprojector.js

@@ -0,0 +1,32 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessChatTabUnavailableError } from './errors.js';
+/**
+ * An `externalErrorProjector` for chat conversations: what a failed model call, tool or resolver
+ * shows in the conversation, never a provider's response text. The host's projection comes first;
+ * then a tab that is gone, a model limit, an HTTP status of the model provider, and a fixed message.
+ */
+export function createFlexHarnessChatErrorProjector(options = {}) {
+    return (error, context) => {
+        const projected = options.project?.(error, context);
+        if (projected)
+            return projected;
+        if (error instanceof FlexHarnessChatTabUnavailableError) {
+            return { name: 'TabUnavailable', message: error.message, code: 'FLEX_CHAT_TAB_UNAVAILABLE' };
+        }
+        const limit = plugins.modelLimitErrorInfo(error);
+        if (limit)
+            return limit;
+        if (context.source === 'agentSession') {
+            const failure = plugins.describeModelFailure(error);
+            if (failure.kind === 'http' && failure.status) {
+                return {
+                    name: 'ModelProviderError',
+                    message: `The model provider answered with HTTP ${failure.status}.`,
+                    code: 'FLEX_CHAT_MODEL_HTTP_ERROR',
+                };
+            }
+        }
+        return { name: 'AssistantError', message: 'The assistant could not complete that request.', code: 'FLEX_CHAT_FAILED' };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmVycm9ycHJvamVjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfY2hhdF9oYXJuZXNzX3NlcnZlci9mdW5jdGlvbnMuZXJyb3Jwcm9qZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFDeEMsT0FBTyxFQUFFLGtDQUFrQyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBVWpFOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsbUNBQW1DLENBQ2pELFVBQWlELEVBQUU7SUFFbkQsT0FBTyxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtRQUN4QixNQUFNLFNBQVMsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ3BELElBQUksU0FBUztZQUFFLE9BQU8sU0FBUyxDQUFDO1FBQ2hDLElBQUksS0FBSyxZQUFZLGtDQUFrQyxFQUFFLENBQUM7WUFDeEQsT0FBTyxFQUFFLElBQUksRUFBRSxnQkFBZ0IsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsMkJBQTJCLEVBQUUsQ0FBQztRQUMvRixDQUFDO1FBQ0QsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ2pELElBQUksS0FBSztZQUFFLE9BQU8sS0FBSyxDQUFDO1FBQ3hCLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxjQUFjLEVBQUUsQ0FBQztZQUN0QyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsb0JBQW9CLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDcEQsSUFBSSxPQUFPLENBQUMsSUFBSSxLQUFLLE1BQU0sSUFBSSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQzlDLE9BQU87b0JBQ0wsSUFBSSxFQUFFLG9CQUFvQjtvQkFDMUIsT0FBTyxFQUFFLHlDQUF5QyxPQUFPLENBQUMsTUFBTSxHQUFHO29CQUNuRSxJQUFJLEVBQUUsNEJBQTRCO2lCQUNuQyxDQUFDO1lBQ0osQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE9BQU8sRUFBRSxnREFBZ0QsRUFBRSxJQUFJLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQztJQUN6SCxDQUFDLENBQUM7QUFDSixDQUFDIn0=

package/dist_ts_chat_harness_server/functions.validation.d.ts

@@ -0,0 +1,18 @@
+import type * as plugins from './plugins.js';
+import type { IFlexHarnessChatCaller, IFlexHarnessChatLimits } from './interfaces.js';
+export declare const BAD_REQUEST_MESSAGE = "The request is malformed. Reload the page and try again.";
+export declare const STOPPED_MESSAGE = "The assistant has stopped. Reload the page and try again.";
+/** One key per tab and scope: the same tab id in two scopes names two tabs. */
+export declare const tabKey: (tabArg: IFlexHarnessChatCaller) => string;
+export declare const isSameTab: (leftArg: IFlexHarnessChatCaller, rightArg: IFlexHarnessChatCaller) => boolean;
+/** A subscription id: 16 random bytes in hex, chosen by the tab. */
+export declare const readRandomId: (valueArg: unknown) => string;
+export declare const readSessionId: (valueArg: unknown, notFoundMessageArg: string) => string;
+export declare const readTitle: (valueArg: unknown, limitsArg: IFlexHarnessChatLimits) => string;
+/** A conversation title from its first message: the first line, shortened. */
+export declare const titleFromMessage: (sendArg: plugins.IHarnessComposerSendDetail) => string;
+/**
+ * The parts of a composer message the hub uses, checked. The composer's model, account and effort
+ * choices are not among them: the host's model resolver decides, from the turn's context.
+ */
+export declare const readSendDetail: (valueArg: unknown, limitsArg: IFlexHarnessChatLimits) => plugins.IHarnessComposerSendDetail;

package/dist_ts_chat_harness_server/functions.validation.js

@@ -0,0 +1,88 @@
+import { FlexHarnessChatRequestError } from './errors.js';
+export const BAD_REQUEST_MESSAGE = 'The request is malformed. Reload the page and try again.';
+export const STOPPED_MESSAGE = 'The assistant has stopped. Reload the page and try again.';
+const RANDOM_ID_PATTERN = /^[0-9a-f]{32}$/;
+const MAX_SESSION_ID_CHARS = 256;
+const TITLE_MAX_CHARS = 80;
+const ATTACHMENT_KINDS = ['image', 'text', 'binary'];
+/** One key per tab and scope: the same tab id in two scopes names two tabs. */
+export const tabKey = (tabArg) => `${tabArg.scopeId}\n${tabArg.tabId}`;
+export const isSameTab = (leftArg, rightArg) => leftArg.tabId === rightArg.tabId && leftArg.scopeId === rightArg.scopeId;
+const badRequest = () => new FlexHarnessChatRequestError(BAD_REQUEST_MESSAGE);
+const isRecord = (valueArg) => !!valueArg && typeof valueArg === 'object' && !Array.isArray(valueArg);
+/** A subscription id: 16 random bytes in hex, chosen by the tab. */
+export const readRandomId = (valueArg) => {
+    if (typeof valueArg !== 'string' || !RANDOM_ID_PATTERN.test(valueArg))
+        throw badRequest();
+    return valueArg;
+};
+export const readSessionId = (valueArg, notFoundMessageArg) => {
+    if (typeof valueArg !== 'string' || !valueArg || valueArg.length > MAX_SESSION_ID_CHARS) {
+        throw new FlexHarnessChatRequestError(notFoundMessageArg);
+    }
+    return valueArg;
+};
+export const readTitle = (valueArg, limitsArg) => {
+    const title = typeof valueArg === 'string' ? valueArg.trim() : '';
+    if (!title || title.length > limitsArg.maxTitleChars) {
+        throw new FlexHarnessChatRequestError(`A title has 1 to ${limitsArg.maxTitleChars} characters.`);
+    }
+    return title;
+};
+/** A conversation title from its first message: the first line, shortened. */
+export const titleFromMessage = (sendArg) => {
+    const text = sendArg.text || sendArg.attachments.map((attachment) => attachment.name).join(', ');
+    const line = text.split('\n').map((part) => part.trim()).find((part) => !!part) || 'New conversation';
+    return line.length > TITLE_MAX_CHARS ? line.slice(0, TITLE_MAX_CHARS - 1).trimEnd() + '…' : line;
+};
+const readOptionalString = (valueArg, maxCharsArg) => {
+    if (valueArg === undefined)
+        return undefined;
+    if (typeof valueArg !== 'string' || valueArg.length > maxCharsArg)
+        throw badRequest();
+    return valueArg;
+};
+const readAttachment = (valueArg, limitsArg) => {
+    if (!isRecord(valueArg)
+        || typeof valueArg.id !== 'string'
+        || typeof valueArg.name !== 'string'
+        || typeof valueArg.mediaType !== 'string'
+        || typeof valueArg.size !== 'number'
+        || typeof valueArg.kind !== 'string'
+        || !ATTACHMENT_KINDS.includes(valueArg.kind)) {
+        throw badRequest();
+    }
+    const text = readOptionalString(valueArg.text, limitsArg.maxAttachmentChars);
+    const dataBase64 = readOptionalString(valueArg.dataBase64, limitsArg.maxAttachmentChars);
+    return {
+        id: valueArg.id.slice(0, 128),
+        name: valueArg.name.slice(0, 255),
+        mediaType: valueArg.mediaType.slice(0, 255),
+        size: valueArg.size,
+        kind: valueArg.kind,
+        ...(text === undefined ? {} : { text }),
+        ...(dataBase64 === undefined ? {} : { dataBase64 }),
+        ...(valueArg.truncated === true ? { truncated: true } : {}),
+    };
+};
+/**
+ * The parts of a composer message the hub uses, checked. The composer's model, account and effort
+ * choices are not among them: the host's model resolver decides, from the turn's context.
+ */
+export const readSendDetail = (valueArg, limitsArg) => {
+    if (!isRecord(valueArg) || typeof valueArg.text !== 'string' || valueArg.text.length > limitsArg.maxMessageChars) {
+        throw badRequest();
+    }
+    if (!Array.isArray(valueArg.attachments) || valueArg.attachments.length > limitsArg.maxAttachments) {
+        throw badRequest();
+    }
+    const attachments = valueArg.attachments.map((entry) => readAttachment(entry, limitsArg));
+    const chars = attachments.reduce((sum, attachment) => sum + (attachment.text?.length ?? 0) + (attachment.dataBase64?.length ?? 0), 0);
+    if (chars > limitsArg.maxAttachmentChars)
+        throw new FlexHarnessChatRequestError('The attachments are too large.');
+    if (!valueArg.text.trim() && attachments.length === 0)
+        throw new FlexHarnessChatRequestError('The message is empty.');
+    // a message sent while a turn runs steers it, whatever delivery the composer chose
+    return { delivery: 'turn', text: valueArg.text, attachments };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLnZhbGlkYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jaGF0X2hhcm5lc3Nfc2VydmVyL2Z1bmN0aW9ucy52YWxpZGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUcxRCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRywwREFBMEQsQ0FBQztBQUM5RixNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsMkRBQTJELENBQUM7QUFDM0YsTUFBTSxpQkFBaUIsR0FBRyxnQkFBZ0IsQ0FBQztBQUMzQyxNQUFNLG9CQUFvQixHQUFHLEdBQUcsQ0FBQztBQUNqQyxNQUFNLGVBQWUsR0FBRyxFQUFFLENBQUM7QUFDM0IsTUFBTSxnQkFBZ0IsR0FBc0IsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0FBRXhFLCtFQUErRTtBQUMvRSxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsQ0FBQyxNQUE4QixFQUFVLEVBQUUsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxPQUFPLEtBQUssTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO0FBRXZHLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLE9BQStCLEVBQUUsUUFBZ0MsRUFBVyxFQUFFLENBQ3RHLE9BQU8sQ0FBQyxLQUFLLEtBQUssUUFBUSxDQUFDLEtBQUssSUFBSSxPQUFPLENBQUMsT0FBTyxLQUFLLFFBQVEsQ0FBQyxPQUFPLENBQUM7QUFFM0UsTUFBTSxVQUFVLEdBQUcsR0FBRyxFQUFFLENBQUMsSUFBSSwyQkFBMkIsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0FBRTlFLE1BQU0sUUFBUSxHQUFHLENBQUMsUUFBaUIsRUFBdUMsRUFBRSxDQUMxRSxDQUFDLENBQUMsUUFBUSxJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7QUFFekUsb0VBQW9FO0FBQ3BFLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxDQUFDLFFBQWlCLEVBQVUsRUFBRTtJQUN4RCxJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUM7UUFBRSxNQUFNLFVBQVUsRUFBRSxDQUFDO0lBQzFGLE9BQU8sUUFBUSxDQUFDO0FBQ2xCLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUFDLFFBQWlCLEVBQUUsa0JBQTBCLEVBQVUsRUFBRTtJQUNyRixJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxDQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsTUFBTSxHQUFHLG9CQUFvQixFQUFFLENBQUM7UUFDeEYsTUFBTSxJQUFJLDJCQUEyQixDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDNUQsQ0FBQztJQUNELE9BQU8sUUFBUSxDQUFDO0FBQ2xCLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLFFBQWlCLEVBQUUsU0FBaUMsRUFBVSxFQUFFO0lBQ3hGLE1BQU0sS0FBSyxHQUFHLE9BQU8sUUFBUSxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7SUFDbEUsSUFBSSxDQUFDLEtBQUssSUFBSSxLQUFLLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUNyRCxNQUFNLElBQUksMkJBQTJCLENBQUMsb0JBQW9CLFNBQVMsQ0FBQyxhQUFhLGNBQWMsQ0FBQyxDQUFDO0lBQ25HLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMsQ0FBQztBQUVGLDhFQUE4RTtBQUM5RSxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLE9BQTJDLEVBQVUsRUFBRTtJQUN0RixNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxJQUFJLE9BQU8sQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2pHLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxrQkFBa0IsQ0FBQztJQUN0RyxPQUFPLElBQUksQ0FBQyxNQUFNLEdBQUcsZUFBZSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxlQUFlLEdBQUcsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7QUFDbkcsQ0FBQyxDQUFDO0FBRUYsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLFFBQWlCLEVBQUUsV0FBbUIsRUFBc0IsRUFBRTtJQUN4RixJQUFJLFFBQVEsS0FBSyxTQUFTO1FBQUUsT0FBTyxTQUFTLENBQUM7SUFDN0MsSUFBSSxPQUFPLFFBQVEsS0FBSyxRQUFRLElBQUksUUFBUSxDQUFDLE1BQU0sR0FBRyxXQUFXO1FBQUUsTUFBTSxVQUFVLEVBQUUsQ0FBQztJQUN0RixPQUFPLFFBQVEsQ0FBQztBQUNsQixDQUFDLENBQUM7QUFFRixNQUFNLGNBQWMsR0FBRyxDQUFDLFFBQWlCLEVBQUUsU0FBaUMsRUFBOEIsRUFBRTtJQUMxRyxJQUNFLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQztXQUNoQixPQUFPLFFBQVEsQ0FBQyxFQUFFLEtBQUssUUFBUTtXQUMvQixPQUFPLFFBQVEsQ0FBQyxJQUFJLEtBQUssUUFBUTtXQUNqQyxPQUFPLFFBQVEsQ0FBQyxTQUFTLEtBQUssUUFBUTtXQUN0QyxPQUFPLFFBQVEsQ0FBQyxJQUFJLEtBQUssUUFBUTtXQUNqQyxPQUFPLFFBQVEsQ0FBQyxJQUFJLEtBQUssUUFBUTtXQUNqQyxDQUFDLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEVBQzVDLENBQUM7UUFDRCxNQUFNLFVBQVUsRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFDRCxNQUFNLElBQUksR0FBRyxrQkFBa0IsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBQzdFLE1BQU0sVUFBVSxHQUFHLGtCQUFrQixDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsU0FBUyxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDekYsT0FBTztRQUNMLEVBQUUsRUFBRSxRQUFRLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDO1FBQzdCLElBQUksRUFBRSxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDO1FBQ2pDLFNBQVMsRUFBRSxRQUFRLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDO1FBQzNDLElBQUksRUFBRSxRQUFRLENBQUMsSUFBSTtRQUNuQixJQUFJLEVBQUUsUUFBUSxDQUFDLElBQTBDO1FBQ3pELEdBQUcsQ0FBQyxJQUFJLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUM7UUFDdkMsR0FBRyxDQUFDLFVBQVUsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxVQUFVLEVBQUUsQ0FBQztRQUNuRCxHQUFHLENBQUMsUUFBUSxDQUFDLFNBQVMsS0FBSyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7S0FDNUQsQ0FBQztBQUNKLENBQUMsQ0FBQztBQUVGOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUM1QixRQUFpQixFQUNqQixTQUFpQyxFQUNHLEVBQUU7SUFDdEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxPQUFPLFFBQVEsQ0FBQyxJQUFJLEtBQUssUUFBUSxJQUFJLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUNqSCxNQUFNLFVBQVUsRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLElBQUksUUFBUSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ25HLE1BQU0sVUFBVSxFQUFFLENBQUM7SUFDckIsQ0FBQztJQUNELE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxjQUFjLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDMUYsTUFBTSxLQUFLLEdBQUcsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxVQUFVLEVBQUUsRUFBRSxDQUNuRCxHQUFHLEdBQUcsQ0FBQyxVQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxVQUFVLEVBQUUsTUFBTSxJQUFJLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2xGLElBQUksS0FBSyxHQUFHLFNBQVMsQ0FBQyxrQkFBa0I7UUFBRSxNQUFNLElBQUksMkJBQTJCLENBQUMsZ0NBQWdDLENBQUMsQ0FBQztJQUNsSCxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxXQUFXLENBQUMsTUFBTSxLQUFLLENBQUM7UUFBRSxNQUFNLElBQUksMkJBQTJCLENBQUMsdUJBQXVCLENBQUMsQ0FBQztJQUN0SCxtRkFBbUY7SUFDbkYsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxJQUFJLEVBQUUsV0FBVyxFQUFFLENBQUM7QUFDaEUsQ0FBQyxDQUFDIn0=

package/dist_ts_chat_harness_server/index.d.ts

@@ -0,0 +1,4 @@
+export { FlexHarnessChatHub, defaultFlexHarnessChatLimits, flexHarnessChatSessionMeta, } from './classes.chathub.js';
+export { FlexHarnessChatRequestError, FlexHarnessChatTabUnavailableError } from './errors.js';
+export { createFlexHarnessChatErrorProjector, type IFlexHarnessChatErrorProjectorOptions, } from './functions.errorprojector.js';
+export type { IFlexHarnessChatCaller, IFlexHarnessChatHubOptions, IFlexHarnessChatLimits, IFlexHarnessChatPeer, IFlexHarnessChatPeers, IFlexHarnessChatTurn, TFlexHarnessChatHubHarness, } from './interfaces.js';

package/dist_ts_chat_harness_server/index.js

@@ -0,0 +1,4 @@
+export { FlexHarnessChatHub, defaultFlexHarnessChatLimits, flexHarnessChatSessionMeta, } from './classes.chathub.js';
+export { FlexHarnessChatRequestError, FlexHarnessChatTabUnavailableError } from './errors.js';
+export { createFlexHarnessChatErrorProjector, } from './functions.errorprojector.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jaGF0X2hhcm5lc3Nfc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxrQkFBa0IsRUFDbEIsNEJBQTRCLEVBQzVCLDBCQUEwQixHQUMzQixNQUFNLHNCQUFzQixDQUFDO0FBQzlCLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM5RixPQUFPLEVBQ0wsbUNBQW1DLEdBRXBDLE1BQU0sK0JBQStCLENBQUMifQ==

package/dist_ts_chat_harness_server/interfaces.d.ts

@@ -0,0 +1,67 @@
+import type * as plugins from './plugins.js';
+/**
+ * Who a request is from, as the host established it: the tab, and the scope whose conversations it
+ * may reach. A tab is named by both: the same tab id in two scopes names two tabs.
+ */
+export interface IFlexHarnessChatCaller {
+    /** the browser tab, a per-page secret; pushes and tool calls of its turns go to it */
+    tabId: string;
+    /** derived by the host from its own authentication, never taken from the browser */
+    scopeId: string;
+}
+/** One tab, reached over its current connection. */
+export interface IFlexHarnessChatPeer {
+    update(push: plugins.IFlexHarnessChatUpdate): Promise<void>;
+    sessions(push: plugins.IFlexHarnessChatSessionsPush): Promise<void>;
+    runTool(request: plugins.IFlexHarnessChatToolRequest, options: {
+        timeoutMs: number;
+        abortSignal?: AbortSignal;
+    }): Promise<plugins.TJsonValue>;
+}
+/** Where the hub finds the tabs it talks to. */
+export interface IFlexHarnessChatPeers {
+    /** The tab's current connection in its scope, or null when the tab is gone. */
+    find(tab: IFlexHarnessChatCaller): Promise<IFlexHarnessChatPeer | null>;
+}
+/** The running turn of a conversation: the tab that started it and the context it was sent with. */
+export interface IFlexHarnessChatTurn<TContext> {
+    readonly scopeId: string;
+    readonly sessionId: string;
+    readonly tabId: string;
+    readonly context: TContext;
+}
+export interface IFlexHarnessChatLimits {
+    /** A turn that runs longer is stopped. Default: 10 minutes. */
+    turnTimeoutMs: number;
+    /** How long a message may wait for a turn that is already ending. Default: 30 seconds. */
+    admissionWaitMs: number;
+    /** A tool call of the tab that is not answered in time fails. Default: 2 minutes. */
+    toolTimeoutMs: number;
+    /** Deltas one update may carry; a tab further behind gets the changed rows. Default: 2000. */
+    maxPendingDeltas: number;
+    /** Characters of a message's text. Default: 100 000. */
+    maxMessageChars: number;
+    /** Attachments of one message. Default: 16. */
+    maxAttachments: number;
+    /** Characters of all attachment payloads of one message, as sent. Default: 8 MiB. */
+    maxAttachmentChars: number;
+    /** Characters of a conversation title. Default: 200. */
+    maxTitleChars: number;
+    /** How often tabs that are gone are forgotten. Default: 5 minutes. */
+    sweepIntervalMs: number;
+}
+/** The harness calls a hub makes; a `FlexHarness` of any scope provides them. */
+export type TFlexHarnessChatHubHarness = Pick<plugins.FlexHarness<unknown>, 'subscribe' | 'listSessions' | 'createSession' | 'getSession' | 'updateSession' | 'deleteSession' | 'getSessionView' | 'getSessionReversionInfo' | 'enqueuePrompt' | 'steerPrompt' | 'getPromptQueueEntry' | 'abort' | 'cancelPrompt' | 'respondToPermission' | 'undoSession' | 'redoSession'>;
+export interface IFlexHarnessChatHubOptions<TContext> {
+    /**
+     * The harness the conversations run on. The host keeps configuring it: its model resolver and
+     * tool provider read the running turn with `hub.turnOf()`.
+     */
+    harness: TFlexHarnessChatHubHarness;
+    peers: IFlexHarnessChatPeers;
+    /** Checks the context a message is sent with and returns it as the turn carries it; throw to refuse. */
+    readContext(value: plugins.TJsonValue): TContext;
+    /** The title of a conversation a message starts. Defaults to the message's first line. */
+    titleOf?(send: plugins.IHarnessComposerSendDetail): string;
+    limits?: Partial<IFlexHarnessChatLimits>;
+}

package/dist_ts_chat_harness_server/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NoYXRfaGFybmVzc19zZXJ2ZXIvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=