@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/channel/history-restore.js

@@ -0,0 +1,214 @@
+/**
+ * "Load earlier" for a session whose durable record is read through the
+ * `transcript` capability: the backend-neutral half.
+ *
+ * - Folding: a row the record can restore is one with a stable identity —
+ *   a tool card (its `callId`), a user / assistant / reasoning row stamped
+ *   with the backend's own `anchor` (`anchoredRow`). Nothing else is folded.
+ * - Restoring: `restoreFoldedRows` re-derives a folded row's full text from
+ *   the record's replay events, matched by those identities, exactly as the
+ *   DSH log restore rebuilds it (text, tool arguments, result, views).
+ * - Older history: `projectHistorySlice` projects an older slice through the
+ *   one shared projector (and the activity projection, so subagent cards
+ *   render) into scratch rows, and `prependHistoryRows` puts them ahead of
+ *   the transcript as restored rows (exempt from folding) with ids below
+ *   every existing row (row ids order "new since" bookkeeping).
+ */
+import { markChannelReadDirty } from '../adapter/channel/read-view.js';
+import { isSuppressedPresentation } from '../agent/presentation.js';
+import { createActivityProjection } from './activity.js';
+import { createChannelProjection, textOfBlocks } from './projection.js';
+/** Whether the durable record can restore a row (the fold predicate). */
+export function anchoredRow(row) {
+    switch (row.kind) {
+        case 'tool':
+            return row.tool !== undefined;
+        case 'user':
+        case 'assistant':
+        case 'reasoning':
+            return row.anchor !== undefined;
+        default:
+            return false;
+    }
+}
+/** Restore folded rows from a durable record; returns the rows restored. */
+export function restoreFoldedRows(rows, record) {
+    const folded = rows.filter(row => row.folded === true);
+    if (folded.length === 0)
+        return 0;
+    const users = new Map();
+    const messages = new Map();
+    const calls = new Map();
+    const results = new Map();
+    for (const event of record) {
+        switch (event.type) {
+            case 'user.message':
+                if (event.source === 'user' && event.anchor !== '')
+                    users.set(event.anchor, event.text);
+                break;
+            case 'assistant.message': {
+                if (event.parentCallId !== undefined)
+                    break;
+                const known = messages.get(event.anchor) ?? { text: '', reasoning: '' };
+                known.text += textOfBlocks(event.blocks);
+                known.reasoning += event.blocks.map(block => (block.type === 'reasoning' ? block.text ?? '' : '')).join('');
+                messages.set(event.anchor, known);
+                break;
+            }
+            case 'tool.call':
+                if (event.parentCallId === undefined)
+                    calls.set(event.callId, event);
+                break;
+            case 'tool.result':
+                if (event.parentCallId === undefined)
+                    results.set(event.callId, event);
+                break;
+            default:
+                break;
+        }
+    }
+    let restored = 0;
+    for (const row of folded) {
+        let found = false;
+        switch (row.kind) {
+            case 'user': {
+                const text = row.anchor === undefined ? undefined : users.get(row.anchor);
+                if (text !== undefined) {
+                    if (text.trim() !== '')
+                        row.text = text;
+                    found = true;
+                }
+                break;
+            }
+            case 'assistant':
+            case 'reasoning': {
+                const message = row.anchor === undefined ? undefined : messages.get(row.anchor);
+                if (message !== undefined) {
+                    const text = (row.kind === 'assistant' ? message.text : message.reasoning).trim();
+                    if (text !== '')
+                        row.text = text;
+                    found = true;
+                }
+                break;
+            }
+            case 'tool': {
+                const tool = row.tool;
+                const call = tool === undefined ? undefined : calls.get(tool.callId);
+                if (tool === undefined || call === undefined)
+                    break;
+                tool.argsFull = call.argsJson;
+                tool.callView = call.presentation === undefined || isSuppressedPresentation(call.presentation) ? undefined : call.presentation;
+                const result = results.get(tool.callId);
+                if (result !== undefined) {
+                    if (result.isError) {
+                        tool.status = 'error';
+                        tool.errorText = result.errorText ?? '';
+                    }
+                    else {
+                        tool.status = 'ok';
+                        tool.resultFull = result.text === '' ? undefined : result.text;
+                        tool.resultView = result.presentation;
+                    }
+                }
+                found = true;
+                break;
+            }
+            default:
+                break;
+        }
+        if (!found)
+            continue;
+        row.folded = false;
+        // Exempt from the next fold pass: a restore must not be undone at once.
+        row.restored = true;
+        markChannelReadDirty(row);
+        restored += 1;
+    }
+    if (restored > 0)
+        markChannelReadDirty(rows);
+    return restored;
+}
+const NOOP = () => undefined;
+/** A throwaway projection state (an older slice paints into its rows). */
+function scratchState(thinkingFold) {
+    const bucket = () => ({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    return {
+        thinkingFold,
+        activeToolCount: 0,
+        spinnerMode: 'requesting',
+        goal: undefined,
+        contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 },
+        tokens: { ...bucket(), peak: bucket(), idle: bucket() },
+        mainCost: {},
+        model: '',
+        lastUsage: undefined,
+        turnUsage: undefined,
+        lastUserText: '',
+        responseChars: 0,
+        tps: undefined,
+        cancelPending: false,
+        working: false,
+        compaction: undefined,
+        turnStart: 0,
+        contextWindow: undefined,
+        reasoningEffort: undefined,
+        sessionTitle: '',
+        agentPreset: undefined,
+        sessionColor: '',
+        costReport: undefined,
+        rows: [],
+        tpsSamples: [],
+        todos: [],
+        subagents: [],
+        backgroundJobs: [],
+    };
+}
+/** Paint an older history slice into fresh rows (settled, no live effects). */
+export function projectHistorySlice(events, thinkingFold) {
+    if (events.length === 0)
+        return [];
+    const state = scratchState(thinkingFold);
+    const rowIds = { value: 0 };
+    const activity = createActivityProjection(() => state, { rowIds });
+    const projector = createChannelProjection(state, {
+        rowIds,
+        resetContextWarning: NOOP,
+        checkContextWarning: NOOP,
+        notify: () => NOOP,
+        jobs: { onOutputSeen: NOOP, onStarted: NOOP },
+        inputConvergence: { cancelInFlight: false },
+        selectionAttached: () => undefined,
+        activity,
+    });
+    try {
+        projector.apply(events, { replay: true });
+        projector.settleStreaming();
+    }
+    finally {
+        activity.dispose();
+    }
+    return state.rows;
+}
+/**
+ * Put older rows ahead of the transcript: restored (never folded again),
+ * not fresh (no reveal animation), ids below every row already there.
+ * Returns the rows prepended.
+ */
+export function prependHistoryRows(rows, older) {
+    if (older.length === 0)
+        return 0;
+    let floor = 0;
+    for (const row of rows)
+        if (row.id < floor)
+            floor = row.id;
+    const first = floor - older.length;
+    const prepared = older.map((row, index) => {
+        const prepended = { ...row, id: first + index, restored: true };
+        delete prepended.fresh;
+        delete prepended.streaming;
+        return prepended;
+    });
+    rows.unshift(...prepared);
+    markChannelReadDirty(rows);
+    return prepared.length;
+}

package/lib/types/channel/interaction.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The channel half of the human-in-the-loop bridge: a non-DSH session
+ * announces its prompts as events, this module parks them in the stores the
+ * TUI renders and routes the user's answers back through the session's typed
+ * capabilities.
+ *
+ *   permission.request  → PermissionStore.park  → panel → permissions.respond
+ *   permission.settled  → PermissionStore.withdraw (the backend took it back)
+ *   question.request    → QuestionStore.ask     → panel → questions.respond / cancel
+ *   question.settled    → abort that ask (the backend took it back)
+ *
+ * A prompt the backend withdrew is never answered again; a session that
+ * leaves the binding withdraws everything it parked (`release`).
+ *
+ * Backend-neutral (`verify:boundary`): stores and capabilities only.
+ */
+import type { SessionCapabilities } from '../agent/capabilities.js';
+import type { AgentEvent } from '../agent/events.js';
+import type { PermissionStore } from './permissions.js';
+import type { QuestionStoreLike } from './questions.js';
+export interface InteractionBridgeDeps {
+    readonly permissions: PermissionStore;
+    readonly questions: QuestionStoreLike;
+    debug(message: string): void;
+}
+/** The bound session as the bridge sees it. */
+export interface InteractionSession {
+    readonly sessionId: string;
+    readonly capabilities: Pick<SessionCapabilities, 'permissions' | 'questions'>;
+}
+/** Attach one session: its events in, its answers out. */
+export declare function attachInteraction(deps: InteractionBridgeDeps, session: InteractionSession): {
+    /** Feed one batch of the bound session's events. */
+    apply(batch: readonly AgentEvent[]): void;
+    /** The session left the binding (or the channel released): withdraw all. */
+    release(): void;
+};
+//# sourceMappingURL=interaction.d.ts.map

package/lib/types/channel/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/channel/interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAmB,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAExE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAA;IACrC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;IACrC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,mBAAmB,EAAE,aAAa,GAAG,WAAW,CAAC,CAAA;CAC9E;AA4BD,0DAA0D;AAC1D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,EAAE,OAAO,EAAE,kBAAkB;IAiDtF,oDAAoD;iBACvC,SAAS,UAAU,EAAE,GAAG,IAAI;IAqBzC,4EAA4E;eACjE,IAAI;EAQlB"}

package/lib/types/channel/interaction.js

@@ -0,0 +1,110 @@
+const errorText = (error) => error instanceof Error ? error.message : String(error);
+/** Whether a questionnaire rejection was the user's own dismissal. */
+const userCancelled = (error) => typeof error === 'object' && error !== null && error.code === 'ASK_CANCELLED';
+/** The store request for one backend ask: ids are question indexes. */
+function storeRequest(request, signal) {
+    return {
+        signal,
+        questions: request.questions.map((question, index) => ({
+            id: String(index),
+            question: question.question,
+            ...(question.header === undefined ? {} : { header: question.header }),
+            ...(question.detail === undefined ? {} : { detail: question.detail }),
+            options: question.options.map(option => ({ label: option.label, ...(option.description === undefined ? {} : { description: option.description }) })),
+            ...(question.multiSelect === true ? { multiSelect: true } : {}),
+            ...(question.intent === undefined ? {} : { intent: question.intent }),
+            ...(question.hideCustomInput === true ? { hideCustomInput: true } : {}),
+            ...(question.defaultSelected === undefined || question.defaultSelected.length === 0 ? {} : { defaultSelected: [...question.defaultSelected] }),
+            ...(question.link === undefined || question.link === '' ? {} : { link: question.link }),
+            ...(question.secret === true ? { secret: true } : {}),
+        })),
+    };
+}
+/** Attach one session: its events in, its answers out. */
+export function attachInteraction(deps, session) {
+    const asks = new Map();
+    let released = false;
+    const park = (event) => {
+        const request = event.request;
+        deps.permissions.park({
+            sessionId: session.sessionId,
+            request,
+            settle: (_outcome, decision) => {
+                // Only a user decision reaches the backend; a withdrawal was the
+                // backend's own act (answering it again would be a second verdict).
+                if (decision === undefined || released)
+                    return;
+                try {
+                    session.capabilities.permissions?.respond(request.requestId, decision);
+                }
+                catch (error) {
+                    deps.debug(`interaction: permission respond failed (${errorText(error)})`);
+                }
+            },
+        });
+    };
+    const ask = (event) => {
+        const request = event.request;
+        if (asks.has(request.requestId))
+            return;
+        const controller = new AbortController();
+        asks.set(request.requestId, controller);
+        void deps.questions.ask(storeRequest(request, controller.signal)).then(answer => {
+            if (controller.signal.aborted || released)
+                return;
+            const byId = new Map(answer.answers.map(item => [item.id, item]));
+            session.capabilities.questions?.respond(request.requestId, {
+                answers: request.questions.map((_, index) => {
+                    const item = byId.get(String(index));
+                    return { selected: item?.selected ?? [], ...(item?.custom === undefined ? {} : { custom: item.custom }) };
+                }),
+            });
+        }, (error) => {
+            // A withdrawn ask (the backend's own abort, a released session) needs
+            // no answer; only the user's dismissal is reported.
+            if (controller.signal.aborted || released || !userCancelled(error))
+                return;
+            session.capabilities.questions?.cancel(request.requestId);
+        }).catch((error) => {
+            deps.debug(`interaction: question respond failed (${errorText(error)})`);
+        }).finally(() => {
+            if (asks.get(request.requestId) === controller)
+                asks.delete(request.requestId);
+        });
+    };
+    return {
+        /** Feed one batch of the bound session's events. */
+        apply(batch) {
+            if (released)
+                return;
+            for (const event of batch) {
+                switch (event.type) {
+                    case 'permission.request':
+                        park(event);
+                        break;
+                    case 'permission.settled':
+                        deps.permissions.withdraw(session.sessionId, event.requestId);
+                        break;
+                    case 'question.request':
+                        ask(event);
+                        break;
+                    case 'question.settled':
+                        asks.get(event.requestId)?.abort();
+                        break;
+                    default:
+                        break;
+                }
+            }
+        },
+        /** The session left the binding (or the channel released): withdraw all. */
+        release() {
+            if (released)
+                return;
+            released = true;
+            deps.permissions.withdrawSession(session.sessionId);
+            for (const controller of asks.values())
+                controller.abort();
+            asks.clear();
+        },
+    };
+}

package/lib/types/channel/job-format.d.ts

@@ -0,0 +1,6 @@
+/** Backend-neutral background-job formatting shared by the job stores, the
+ *  transcript card, the `/jobs` panel and the status-line chip. */
+import type { BackgroundJobState } from '../adapter/ports/channel-view.js';
+/** `3s` under a minute, `3m12s` under an hour, `1h02m` beyond — transcript-card compact. */
+export declare function formatJobDuration(job: Pick<BackgroundJobState, 'startedAt' | 'finishedAt'>, now?: number): string;
+//# sourceMappingURL=job-format.d.ts.map

package/lib/types/channel/job-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-format.d.ts","sourceRoot":"","sources":["../../../src/channel/job-format.ts"],"names":[],"mappings":"AAAA;mEACmE;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAE1E,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,YAAY,CAAC,EAAE,GAAG,SAAa,GAAG,MAAM,CAQrH"}

package/lib/types/channel/job-format.js

@@ -0,0 +1,12 @@
+/** `3s` under a minute, `3m12s` under an hour, `1h02m` beyond — transcript-card compact. */
+export function formatJobDuration(job, now = Date.now()) {
+    const end = job.finishedAt ?? now;
+    const seconds = Math.max(0, Math.floor((end - job.startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h${String(minutes % 60).padStart(2, '0')}m`;
+}

package/lib/types/channel/live-output.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The bounded live-output tail of a running tool (`tool.output`, N4): the
+ * shared projector appends every chunk here and publishes the retained
+ * text on the tool row; the card renders the newest few lines of it.
+ *
+ * Bounded twice, so a chatty command can never grow the row: at most
+ * {@link LIVE_OUTPUT_MAX_LINES} lines and {@link LIVE_OUTPUT_MAX_CHARS}
+ * characters (16 KiB counted in UTF-16 code units). Whole lines leave from
+ * the head first and are counted in `dropped`; a single line longer than
+ * the whole budget keeps its newest characters (cut on a code-point
+ * boundary). The text stays raw (ANSI, carriage returns): sanitizing is
+ * the renderer's job, over the few lines it actually shows.
+ *
+ * Pure and allocation-light: an append scans only the new chunk for line
+ * breaks (the running count rides on the tail) plus one slice when a
+ * bound is crossed.
+ */
+/** Lines a tail keeps. */
+export declare const LIVE_OUTPUT_MAX_LINES = 200;
+/** Characters a tail keeps (16 KiB of UTF-16 code units). */
+export declare const LIVE_OUTPUT_MAX_CHARS: number;
+/** One running call's retained output. */
+export interface LiveOutputTail {
+    /** The retained text, oldest first; the last line may still be open. */
+    readonly text: string;
+    /** Line breaks in `text` (kept so an append never rescans the tail). */
+    readonly breaks: number;
+    /** Whole lines dropped from the head so far. */
+    readonly dropped: number;
+}
+/** Lines in a tail's text (a trailing break closes the last line). */
+export declare function liveOutputLineCount(tail: Pick<LiveOutputTail, 'text' | 'breaks'>): number;
+/** Append one chunk, keeping the tail within both bounds. */
+export declare function appendLiveOutput(tail: LiveOutputTail | undefined, chunk: string): LiveOutputTail;
+//# sourceMappingURL=live-output.d.ts.map

package/lib/types/channel/live-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-output.d.ts","sourceRoot":"","sources":["../../../src/channel/live-output.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,0BAA0B;AAC1B,eAAO,MAAM,qBAAqB,MAAM,CAAA;AACxC,6DAA6D;AAC7D,eAAO,MAAM,qBAAqB,QAAY,CAAA;AAE9C,0CAA0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AASD,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG,MAAM,CAGzF;AAED,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,CAmChG"}

package/lib/types/channel/live-output.js

@@ -0,0 +1,74 @@
+/**
+ * The bounded live-output tail of a running tool (`tool.output`, N4): the
+ * shared projector appends every chunk here and publishes the retained
+ * text on the tool row; the card renders the newest few lines of it.
+ *
+ * Bounded twice, so a chatty command can never grow the row: at most
+ * {@link LIVE_OUTPUT_MAX_LINES} lines and {@link LIVE_OUTPUT_MAX_CHARS}
+ * characters (16 KiB counted in UTF-16 code units). Whole lines leave from
+ * the head first and are counted in `dropped`; a single line longer than
+ * the whole budget keeps its newest characters (cut on a code-point
+ * boundary). The text stays raw (ANSI, carriage returns): sanitizing is
+ * the renderer's job, over the few lines it actually shows.
+ *
+ * Pure and allocation-light: an append scans only the new chunk for line
+ * breaks (the running count rides on the tail) plus one slice when a
+ * bound is crossed.
+ */
+/** Lines a tail keeps. */
+export const LIVE_OUTPUT_MAX_LINES = 200;
+/** Characters a tail keeps (16 KiB of UTF-16 code units). */
+export const LIVE_OUTPUT_MAX_CHARS = 16 * 1024;
+/** Line breaks in `text[from, to)`. */
+function countBreaks(text, from = 0, to = text.length) {
+    let count = 0;
+    for (let at = text.indexOf('\n', from); at !== -1 && at < to; at = text.indexOf('\n', at + 1))
+        count += 1;
+    return count;
+}
+/** Lines in a tail's text (a trailing break closes the last line). */
+export function liveOutputLineCount(tail) {
+    if (tail.text === '')
+        return 0;
+    return tail.breaks + (tail.text.endsWith('\n') ? 0 : 1);
+}
+/** Append one chunk, keeping the tail within both bounds. */
+export function appendLiveOutput(tail, chunk) {
+    let text = (tail?.text ?? '') + chunk;
+    let breaks = (tail?.breaks ?? 0) + countBreaks(chunk);
+    let dropped = tail?.dropped ?? 0;
+    const lines = liveOutputLineCount({ text, breaks });
+    if (lines > LIVE_OUTPUT_MAX_LINES) {
+        const excess = lines - LIVE_OUTPUT_MAX_LINES;
+        let cut = 0;
+        for (let index = 0; index < excess; index += 1)
+            cut = text.indexOf('\n', cut) + 1;
+        text = text.slice(cut);
+        breaks -= excess;
+        dropped += excess;
+    }
+    if (text.length > LIVE_OUTPUT_MAX_CHARS) {
+        const from = text.length - LIVE_OUTPUT_MAX_CHARS;
+        // The first line that starts inside the budget: a break at from - 1 or
+        // later. When that break is the text's last character (one huge closed
+        // line) or there is none (one huge open line), the newest line itself
+        // is clipped instead.
+        const at = text.indexOf('\n', Math.max(0, from - 1));
+        let start;
+        if (at !== -1 && at + 1 < text.length) {
+            start = at + 1;
+        }
+        else {
+            start = from;
+            const code = text.charCodeAt(start);
+            // Never start on the low half of a surrogate pair.
+            if (code >= 0xdc00 && code <= 0xdfff)
+                start += 1;
+        }
+        const removed = countBreaks(text, 0, start);
+        text = text.slice(start);
+        breaks -= removed;
+        dropped += removed;
+    }
+    return { text, breaks, dropped };
+}

package/lib/types/channel/model-capabilities.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderModelCapabilities } from '../adapter/ports/channel-settings.js';
+export declare const PROVIDER_REASONING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export declare const MODEL_CAPABILITY_FIELDS: readonly ["contextWindow", "maxTokens", "reasoningEfforts", "input"];
+/** Empty restores inheritance; K/M are decimal token-count suffixes. */
+export declare function parseModelCapacity(text: string): number | undefined;
+/** Editable level list, including explicit wire aliases and off-by-omission. */
+export declare function formatModelReasoning(value: ProviderModelCapabilities['reasoningEfforts']): string;
+/** Decode offered levels, not the current conversation's selected effort. */
+export declare function parseModelReasoning(text: string): ProviderModelCapabilities['reasoningEfforts'];
+//# sourceMappingURL=model-capabilities.d.ts.map

package/lib/types/channel/model-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-capabilities.d.ts","sourceRoot":"","sources":["../../../src/channel/model-capabilities.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AAErF,eAAO,MAAM,yBAAyB,sEAAuE,CAAA;AAC7G,eAAO,MAAM,uBAAuB,sEAAuE,CAAA;AAE3G,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOnE;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,CAAC,kBAAkB,CAAC,GAAG,MAAM,CAMjG;AAED,6EAA6E;AAC7E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,yBAAyB,CAAC,kBAAkB,CAAC,CAiB/F"}

package/lib/types/channel/model-capabilities.js

@@ -0,0 +1,51 @@
+/**
+ * Provider model-capability parsing/formatting: the neutral surface the
+ * TUI's model editor consumes — next to channel/sanitize for the same
+ * reason: UI layers may only import TYPES from src/dsh-adapter/, and ports/
+ * admits no imports from outside itself (verify:adapter-ports), so a
+ * user-language error message rules ports out. Validation errors raise in
+ * the user's language since the editor surfaces them verbatim.
+ */
+import { t } from '../i18n.js';
+export const PROVIDER_REASONING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const MODEL_CAPABILITY_FIELDS = ['contextWindow', 'maxTokens', 'reasoningEfforts', 'input'];
+/** Empty restores inheritance; K/M are decimal token-count suffixes. */
+export function parseModelCapacity(text) {
+    const value = text.trim();
+    if (value === '')
+        return undefined;
+    const match = /^(\d+(?:\.\d+)?)\s*([km])?$/i.exec(value);
+    const count = match === null ? NaN : Number(match[1]) * (match[2]?.toLowerCase() === 'm' ? 1_000_000 : match[2] ? 1000 : 1);
+    if (!Number.isSafeInteger(count) || count <= 0)
+        throw new Error(t('provider-model-capacity-invalid'));
+    return count;
+}
+/** Editable level list, including explicit wire aliases and off-by-omission. */
+export function formatModelReasoning(value) {
+    if (value === undefined)
+        return '';
+    if (value === false)
+        return 'none';
+    return Object.entries(value).map(([level, wire]) => wire === null || (wire === level && level !== 'off') ? level : `${level}=${wire}`).join(', ');
+}
+/** Decode offered levels, not the current conversation's selected effort. */
+export function parseModelReasoning(text) {
+    const value = text.trim();
+    if (value === '')
+        return undefined;
+    if (value.toLowerCase() === 'none' || value.toLowerCase() === 'false')
+        return false;
+    const entries = value.split(',').map(part => {
+        const [rawLevel, ...rest] = part.trim().split('=');
+        const level = rawLevel.toLowerCase();
+        const wire = rest.length === 0 ? (level === 'off' ? null : level) : rest.join('=').trim();
+        return [level, wire];
+    });
+    if (entries.some(([level, wire]) => !PROVIDER_REASONING_LEVELS.some(id => id === level)
+        || (wire !== null && wire.length === 0))
+        || new Set(entries.map(([level]) => level)).size !== entries.length
+        || !entries.some(([level]) => level !== 'off')) {
+        throw new Error(t('provider-model-reasoning-invalid'));
+    }
+    return Object.fromEntries(entries);
+}