@qvac/harness 0.0.0 → 0.1.1

package/dist-lib/lib/capabilities/download.d.ts

@@ -0,0 +1,46 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ModelProgressUpdate } from '@qvac/sdk';
+import { Readable } from 'streamx';
+import { type ModelAddon, type ModelRegistrySdk } from '../models/model-source.ts';
+export type DownloadProgress = Omit<ModelProgressUpdate, 'type'>;
+export type DownloadProgressEvent = {
+    type: 'progress';
+} & DownloadProgress;
+export type DownloadCompleteEvent = {
+    type: 'complete';
+    assetId: string;
+};
+export type DownloadErrorEvent = {
+    type: 'error';
+    message: string;
+};
+export type DownloadAbortedEvent = {
+    type: 'aborted';
+};
+export type DownloadEvent = DownloadProgressEvent | DownloadCompleteEvent | DownloadErrorEvent | DownloadAbortedEvent;
+export interface DownloadSdk extends ModelRegistrySdk {
+    downloadAsset(options: {
+        assetSrc: string;
+        seed?: boolean;
+        onProgress?: (progress: DownloadProgress) => void;
+    }): Promise<string> & {
+        requestId?: string;
+    };
+    cancel?(params: {
+        requestId: string;
+    }): Promise<void>;
+}
+export interface DownloadArgs {
+    model: string;
+    addon?: ModelAddon;
+    seed?: boolean;
+    signal?: BareAbortSignal;
+    projection?: string;
+    companions?: ReadonlyArray<string>;
+    assetSizes?: Readonly<Record<string, number>>;
+}
+export type SdkOrLoader = DownloadSdk | (() => Promise<DownloadSdk>);
+export interface DownloadEventStream extends Readable {
+    [Symbol.asyncIterator](): AsyncIterableIterator<DownloadEvent>;
+}
+export declare function download(sdkOrLoader: SdkOrLoader, args: DownloadArgs, onSettled?: () => void): DownloadEventStream;

package/dist-lib/lib/capabilities/download.js

@@ -0,0 +1,124 @@
+import { Readable } from 'streamx';
+import { errorMessage } from "../error-fields.js";
+import { resolveModelSrc } from "../models/model-source.js";
+const noop = () => { };
+export function download(sdkOrLoader, args, onSettled) {
+    const { model, addon = 'llm', seed, signal, projection, companions = [], assetSizes } = args;
+    const loadSdk = typeof sdkOrLoader === 'function' ? sdkOrLoader : () => Promise.resolve(sdkOrLoader);
+    let settled = false;
+    let opDone = false;
+    let cancelSent = false;
+    let sdkRef = null;
+    let requestId;
+    const finish = (event) => {
+        if (settled)
+            return;
+        settled = true;
+        stream.push(event);
+        stream.push(null);
+        onSettled?.();
+    };
+    const cancelOp = () => {
+        if (cancelSent || opDone || !requestId || !sdkRef?.cancel)
+            return;
+        cancelSent = true;
+        sdkRef.cancel({ requestId }).catch(noop);
+    };
+    const onAbort = () => {
+        cancelOp();
+        finish({ type: 'aborted' });
+    };
+    const onProgress = (p) => {
+        if (!settled)
+            stream.push({ ...p, type: 'progress' });
+    };
+    const start = async () => {
+        if (signal?.aborted)
+            return finish({ type: 'aborted' });
+        try {
+            sdkRef = await loadSdk();
+            const resolved = await resolveModelSrc(sdkRef, model, addon);
+            const mainSrc = typeof resolved === 'string' ? resolved : resolved.src;
+            const srcs = Array.from(new Set([mainSrc, ...(projection ? [projection] : []), ...companions]));
+            const aggregate = aggregateLayout(srcs, assetSizes);
+            let mainAssetId = '';
+            for (let i = 0; i < srcs.length; i++) {
+                if (signal?.aborted)
+                    return finish({ type: 'aborted' });
+                const progress = aggregate
+                    ? aggregateProgressHandler(onProgress, {
+                        setKey: mainSrc,
+                        currentFile: srcs[i],
+                        fileIndex: i,
+                        totalFiles: srcs.length,
+                        offset: aggregate.offsets[i],
+                        expectedSize: aggregate.sizes[i],
+                        totalBytes: aggregate.totalBytes
+                    })
+                    : onProgress;
+                const op = sdkRef.downloadAsset({ assetSrc: srcs[i], seed, onProgress: progress });
+                requestId = op.requestId;
+                const assetId = await op;
+                if (i === 0)
+                    mainAssetId = assetId;
+            }
+            opDone = true;
+            finish({ type: 'complete', assetId: mainAssetId });
+        }
+        catch (err) {
+            opDone = true;
+            if (signal?.aborted)
+                return finish({ type: 'aborted' });
+            finish({ type: 'error', message: errorMessage(err) });
+        }
+    };
+    const stream = new Readable({
+        open(cb) {
+            signal?.addEventListener?.('abort', onAbort, { once: true });
+            void start();
+            cb(null);
+        },
+        destroy(cb) {
+            signal?.removeEventListener?.('abort', onAbort);
+            cancelOp();
+            cb(null);
+        }
+    });
+    return stream;
+}
+function aggregateLayout(sources, assetSizes) {
+    if (!assetSizes)
+        return null;
+    const offsets = [];
+    const sizes = [];
+    let totalBytes = 0;
+    for (const source of sources) {
+        const size = assetSizes[source];
+        if (!Number.isFinite(size) || size <= 0)
+            return null;
+        offsets.push(totalBytes);
+        sizes.push(size);
+        totalBytes += size;
+    }
+    return { offsets, sizes, totalBytes };
+}
+function aggregateProgressHandler(onProgress, context) {
+    return (progress) => onProgress(frameProgress(progress, context));
+}
+function frameProgress(progress, context) {
+    const assetDownloaded = Math.min(Math.max(progress.downloaded, 0), context.expectedSize);
+    const overallDownloaded = Math.min(context.offset + assetDownloaded, context.totalBytes);
+    const overallPercentage = Number(((overallDownloaded / context.totalBytes) * 100).toFixed(2));
+    return {
+        ...progress,
+        fileSetInfo: {
+            setKey: context.setKey,
+            currentFile: context.currentFile,
+            fileIndex: context.fileIndex,
+            totalFiles: context.totalFiles,
+            overallDownloaded,
+            overallTotal: context.totalBytes,
+            overallPercentage
+        }
+    };
+}

package/dist-lib/lib/capabilities/embed.d.ts

@@ -0,0 +1,20 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+export interface EmbedSdk {
+    embed(params: {
+        modelId: string;
+        text: string[];
+    }): Promise<{
+        embedding: number[][];
+    }>;
+}
+export interface EmbedArgs {
+    modelId: string;
+    texts: string[];
+}
+export interface EmbedContext {
+    model: string;
+    texts: string[];
+    signal?: BareAbortSignal;
+}
+export type EmbedLane = (sdk: EmbedSdk, args: EmbedArgs) => Promise<number[][]>;
+export declare function createEmbedLane(): EmbedLane;

package/dist-lib/lib/capabilities/embed.js

@@ -0,0 +1,13 @@
+export function createEmbedLane() {
+    let tail = Promise.resolve();
+    return (sdk, { modelId, texts }) => {
+        const job = tail.then(async () => {
+            if (texts.length === 0)
+                return [];
+            const { embedding } = await sdk.embed({ modelId, text: texts });
+            return embedding;
+        });
+        tail = job.catch(() => { });
+        return job;
+    };
+}

package/dist-lib/lib/capabilities/kv-cache.d.ts

@@ -0,0 +1,13 @@
+export type KvCacheDeletionResult = {
+    status: 'success';
+} | {
+    status: 'failure';
+    error: string;
+} | {
+    status: 'unsupported';
+    error: string;
+};
+type KvCacheSdk = Pick<typeof import('@qvac/sdk'), 'deleteCache'>;
+export declare function deleteAllKvCaches(loadSdk: () => Promise<KvCacheSdk>): Promise<KvCacheDeletionResult>;
+export declare function unsupportedKvCacheDeletion(error?: string): KvCacheDeletionResult;
+export {};

package/dist-lib/lib/capabilities/kv-cache.js

@@ -0,0 +1,21 @@
+export async function deleteAllKvCaches(loadSdk) {
+    try {
+        const sdk = await loadSdk();
+        const result = await sdk.deleteCache({ all: true });
+        return result.success
+            ? { status: 'success' }
+            : { status: 'failure', error: 'SDK cache deletion did not succeed' };
+    }
+    catch (error) {
+        return {
+            status: 'failure',
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+export function unsupportedKvCacheDeletion(error) {
+    return {
+        status: 'unsupported',
+        error: error ?? 'Harness does not support KV cache deletion'
+    };
+}

package/dist-lib/lib/capabilities/prompt-prefix.d.ts

@@ -0,0 +1,6 @@
+import type { Tool as SdkTool } from '@qvac/sdk';
+export interface PromptPrefix {
+    system: string | null;
+    tools: ReadonlyArray<SdkTool> | undefined;
+}
+export declare function promptPrefixHash({ system, tools }: PromptPrefix): string;

package/dist-lib/lib/capabilities/prompt-prefix.js

@@ -0,0 +1,10 @@
+import crypto from 'crypto';
+export function promptPrefixHash({ system, tools }) {
+    const hash = crypto.createHash('sha256');
+    hash.update(system ?? '');
+    for (const tool of tools ?? []) {
+        hash.update('\0');
+        hash.update(JSON.stringify(tool));
+    }
+    return hash.digest('hex').slice(0, 12);
+}

package/dist-lib/lib/capabilities/speech-lexicon.d.ts

@@ -0,0 +1,5 @@
+export type SpeechLang = 'en';
+export declare const CURRENCY_CODES: ReadonlyArray<readonly [string, string]>;
+type Symbols = ReadonlyArray<readonly [string, string]>;
+export declare const SPEECH_LEXICON: Readonly<Record<SpeechLang, Symbols>>;
+export {};

package/dist-lib/lib/capabilities/speech-lexicon.js

@@ -0,0 +1,32 @@
+export const CURRENCY_CODES = [
+    ['R$', 'BRL'],
+    ['$', 'USD'],
+    ['€', 'EUR'],
+    ['£', 'GBP'],
+    ['¥', 'JPY']
+];
+const EN = [
+    ['<=', ' less than or equal to '],
+    ['>=', ' greater than or equal to '],
+    ['!=', ' not equal to '],
+    ['≤', ' less than or equal to '],
+    ['≥', ' greater than or equal to '],
+    ['≠', ' not equal to '],
+    ['≈', ' approximately '],
+    ['%', ' percent '],
+    ['=', ' equals '],
+    ['+', ' plus '],
+    ['<', ' less than '],
+    ['>', ' greater than '],
+    ['×', ' times '],
+    ['/', ' slash '],
+    ['⁄', ' slash '],
+    ['÷', ' divided by '],
+    ['&', ' and '],
+    ['@', ' at '],
+    ['°', ' degrees '],
+    ['±', ' plus or minus ']
+];
+export const SPEECH_LEXICON = {
+    en: EN
+};

package/dist-lib/lib/capabilities/speech-text.d.ts

@@ -0,0 +1,6 @@
+import { type SpeechLang } from './speech-lexicon.ts';
+export interface SpeechText {
+    text: string;
+    dropped: string[];
+}
+export declare function normalizeForSpeech(text: string, lang?: SpeechLang): SpeechText;

package/dist-lib/lib/capabilities/speech-text.js

@@ -0,0 +1,79 @@
+import { ascii } from 'asenion';
+import { CURRENCY_CODES, SPEECH_LEXICON } from "./speech-lexicon.js";
+const EMOJI_MODIFIERS = /[\uFE0E\uFE0F\u200D\u{1F3FB}-\u{1F3FF}]/gu;
+const UNSPEAKABLE = /[^\nA-Za-z0-9 .,;:!?'"()\u002D_]/gu;
+export function normalizeForSpeech(text, lang = 'en') {
+    return filterUnspeakable(toSpokenText(text, lang));
+}
+function toSpokenText(text, lang) {
+    const folded = stripMarkup(foldWhitespace(text)).normalize('NFKC').replace(EMOJI_MODIFIERS, '');
+    return ascii(verbalize(folded, lang));
+}
+function foldWhitespace(text) {
+    return text.replace(/\r\n?/g, '\n').replace(/\t/g, ' ');
+}
+function stripMarkup(text) {
+    return (text
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, ' ')
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/\[([^\]]+)\]\[[^\]]*\]/g, '$1')
+        .replace(/^#{1,6}\s+/gm, '')
+        .replace(/^\s*[-*+]\s+/gm, '')
+        .replace(/^[ ]*>(?!=)[ ]?/gm, '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/~~([^~]+)~~/g, '$1'));
+}
+function verbalize(text, lang) {
+    let spoken = text.replace(/#(?=\d)/g, ' number ');
+    for (const [symbol, code] of CURRENCY_CODES) {
+        spoken = spoken.replace(amountAfter(symbol), (_match, amount) => {
+            return ` ${amount} ${currencyName(code, lang, amount === '1')} `;
+        });
+        spoken = spoken.split(symbol).join(` ${currencyName(code, lang, false)} `);
+    }
+    for (const [symbol, spokenForm] of SPEECH_LEXICON[lang]) {
+        spoken = spoken.split(symbol).join(spokenForm);
+    }
+    return spoken;
+}
+function amountAfter(symbol) {
+    return new RegExp(`${escapeRegExp(symbol)}\\s?(\\d[\\d.,]*)`, 'g');
+}
+function escapeRegExp(text) {
+    return text.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+}
+function currencyName(code, lang, singular) {
+    const key = `${lang}:${code}:${singular}`;
+    const hit = CURRENCY_NAMES.get(key);
+    if (hit !== undefined)
+        return hit;
+    const parts = new Intl.NumberFormat(lang, {
+        style: 'currency',
+        currency: code,
+        currencyDisplay: 'name',
+        maximumFractionDigits: 0
+    }).formatToParts(singular ? 1 : 2);
+    const name = parts.find((part) => part.type === 'currency')?.value ?? code;
+    CURRENCY_NAMES.set(key, name);
+    return name;
+}
+const CURRENCY_NAMES = new Map();
+function filterUnspeakable(text) {
+    const dropped = [];
+    const kept = text.replace(UNSPEAKABLE, (char) => {
+        dropped.push(char);
+        return '';
+    });
+    return {
+        text: kept
+            .replace(/ +/g, ' ')
+            .replace(/ *\n */g, '\n')
+            .replace(/\n{2,}/g, '\n')
+            .trim(),
+        dropped
+    };
+}

package/dist-lib/lib/capabilities/tool-names.d.ts

@@ -0,0 +1,3 @@
+export declare const SKILL_TOOL_NAME = "skill";
+export declare const WEB_SEARCH_TOOL_NAME = "web_search";
+export declare const MCP_CALL_TOOL_NAME = "mcp_call";

package/dist-lib/lib/capabilities/tool-names.js

@@ -0,0 +1,3 @@
+export const SKILL_TOOL_NAME = 'skill';
+export const WEB_SEARCH_TOOL_NAME = 'web_search';
+export const MCP_CALL_TOOL_NAME = 'mcp_call';

package/dist-lib/lib/capabilities/tool-selection.d.ts

@@ -0,0 +1,43 @@
+export interface ToolGrantSource<T extends {
+    bin: string;
+}> {
+    name: string;
+    tools: ReadonlyArray<string>;
+    cliValidator?: T;
+}
+export interface ToolGrants<T extends {
+    bin: string;
+}> {
+    grantedNames: Set<string>;
+    grantedOwners: Map<string, Set<string>>;
+    grantedOps: Map<string, T[]>;
+}
+export declare function collectToolGrants<T extends {
+    bin: string;
+}>(skills: ReadonlyArray<ToolGrantSource<T>>): ToolGrants<T>;
+export interface SkillActivation {
+    skillsSelected: boolean;
+    enabledSkills: ReadonlyArray<string>;
+    mention: string | null;
+    loadedSkills: ReadonlySet<string>;
+}
+export declare function skillsAreSelected(scope: 'all' | 'selected' | null | undefined, hasAgent: boolean): boolean;
+export declare function skillIsActive(name: string, { skillsSelected, enabledSkills, mention, loadedSkills }: SkillActivation): boolean;
+export interface SelectableTool {
+    name: string;
+    skillGated?: boolean | undefined;
+    rootsRequired?: boolean | undefined;
+    writeRootsRequired?: boolean | undefined;
+    owningSkill?: string | undefined;
+}
+export interface ToolGateInputs {
+    toolsSelected: boolean;
+    allowlist: ReadonlyArray<string>;
+    grantedNames: ReadonlySet<string>;
+    grantedOwners: ReadonlyMap<string, ReadonlySet<string>>;
+    hasRoots: boolean;
+    hasWriteRoots: boolean;
+    hasActiveSkills: boolean;
+}
+export declare function isSelected(scope: 'all' | 'selected' | null | undefined, list?: ReadonlyArray<string> | null): boolean;
+export declare function enabledTools<T extends SelectableTool>(tools: ReadonlyArray<T>, { toolsSelected, allowlist, grantedNames, grantedOwners, hasRoots, hasWriteRoots, hasActiveSkills }: ToolGateInputs): T[];

package/dist-lib/lib/capabilities/tool-selection.js

@@ -0,0 +1,60 @@
+import { parseToolGrant } from "../tools/skills/tool-grants.js";
+import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./tool-names.js";
+export function collectToolGrants(skills) {
+    const grants = {
+        grantedNames: new Set(),
+        grantedOwners: new Map(),
+        grantedOps: new Map()
+    };
+    for (const skill of skills) {
+        for (const entry of skill.tools) {
+            const { name, scope } = parseToolGrant(entry);
+            grants.grantedNames.add(name);
+            const owners = grants.grantedOwners.get(name) ?? new Set();
+            owners.add(skill.name);
+            grants.grantedOwners.set(name, owners);
+            if (scope) {
+                if (skill.cliValidator && skill.cliValidator.bin === scope.toLowerCase()) {
+                    const list = grants.grantedOps.get(scope.toLowerCase()) ?? [];
+                    list.push(skill.cliValidator);
+                    grants.grantedOps.set(scope.toLowerCase(), list);
+                }
+            }
+        }
+    }
+    return grants;
+}
+export function skillsAreSelected(scope, hasAgent) {
+    return hasAgent && scope !== 'all';
+}
+export function skillIsActive(name, { skillsSelected, enabledSkills, mention, loadedSkills }) {
+    if (!skillsSelected)
+        return true;
+    return enabledSkills.includes(name) || name === mention || loadedSkills.has(name);
+}
+export function isSelected(scope, list) {
+    return (scope ?? (list?.length ? 'selected' : 'all')) === 'selected';
+}
+export function enabledTools(tools, { toolsSelected, allowlist, grantedNames, grantedOwners, hasRoots, hasWriteRoots, hasActiveSkills }) {
+    return tools.filter((tool) => {
+        if (tool.name === SKILL_TOOL_NAME)
+            return hasActiveSkills;
+        if (tool.owningSkill !== undefined) {
+            return grantedOwners.get(tool.name)?.has(tool.owningSkill) === true;
+        }
+        if (tool.name === WEB_SEARCH_TOOL_NAME &&
+            toolsSelected &&
+            !allowlist.includes(WEB_SEARCH_TOOL_NAME)) {
+            return false;
+        }
+        if (tool.rootsRequired)
+            return hasRoots;
+        if (tool.writeRootsRequired)
+            return hasWriteRoots;
+        if (tool.skillGated)
+            return grantedNames.has(tool.name);
+        if (!toolsSelected)
+            return true;
+        return allowlist.includes(tool.name) || grantedNames.has(tool.name);
+    });
+}

package/dist-lib/lib/capabilities/tool-turns.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from './completion.ts';
+export declare const DIRECT_CALL_ID = "call-direct";
+export declare const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export declare function toolResultTurn(name: string, id: string, output: unknown): string;
+export declare function skillLoadedTurn(name: string): string;
+export declare function attachmentTurn(name: string, result: unknown): string | null;
+export declare function loadedSkillsFrom(messages: readonly Message[]): Set<string>;
+export declare function loadedSkillFilesFrom(messages: readonly Message[]): Map<string, Set<string>>;
+export declare function withoutSkillLoadTurns(messages: readonly Message[], name: string): Message[];

package/dist-lib/lib/capabilities/tool-turns.js

@@ -0,0 +1,101 @@
+import { SKILL_TOOL_NAME } from "./tool-names.js";
+export const DIRECT_CALL_ID = 'call-direct';
+export const TOOL_CONTINUATION_NUDGE = "[Tool results above. Continue the user's request: call the next tool, or answer.]";
+export function toolResultTurn(name, id, output) {
+    return `[Tool: ${name} (${id})]\n${JSON.stringify(historyPayload(output))}`;
+}
+export function skillLoadedTurn(name) {
+    return toolResultTurn(SKILL_TOOL_NAME, DIRECT_CALL_ID, {
+        name,
+        content: `${name} was loaded in an earlier turn but its instructions are not in this context. Call the skill tool with this name again before doing its work.`
+    });
+}
+function refFrom(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const record = value;
+    if (typeof record.attachmentId !== 'string')
+        return null;
+    const ref = { attachmentId: record.attachmentId };
+    const name = typeof record.fileName === 'string' ? record.fileName : '';
+    const dot = name.lastIndexOf('.');
+    if (dot > 0)
+        ref.type = name.slice(dot + 1).toLowerCase();
+    return ref;
+}
+export function attachmentTurn(name, result) {
+    const direct = refFrom(result);
+    if (direct)
+        return toolResultTurn(name, DIRECT_CALL_ID, direct);
+    const listed = result?.attachments;
+    if (!Array.isArray(listed))
+        return null;
+    const refs = [];
+    for (const entry of listed) {
+        const ref = refFrom(entry);
+        if (ref)
+            refs.push(ref);
+    }
+    if (!refs.length)
+        return null;
+    return toolResultTurn(name, DIRECT_CALL_ID, { attachments: refs });
+}
+export function loadedSkillsFrom(messages) {
+    const loaded = new Set();
+    for (const { name } of skillLoadPayloads(messages))
+        loaded.add(name);
+    return loaded;
+}
+export function loadedSkillFilesFrom(messages) {
+    const loaded = new Map();
+    for (const { name, file } of skillLoadPayloads(messages)) {
+        if (!file)
+            continue;
+        const files = loaded.get(name) ?? new Set();
+        files.add(file);
+        loaded.set(name, files);
+    }
+    return loaded;
+}
+export function withoutSkillLoadTurns(messages, name) {
+    return messages.filter((turn) => {
+        const payload = skillLoadPayload(turn);
+        return !payload || payload.name !== name || payload.file !== undefined;
+    });
+}
+function* skillLoadPayloads(messages) {
+    for (const turn of messages) {
+        const payload = skillLoadPayload(turn);
+        if (payload)
+            yield payload;
+    }
+}
+function skillLoadPayload(turn) {
+    if (turn.role !== 'tool')
+        return null;
+    const text = String(turn.content ?? '');
+    if (!text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`))
+        return null;
+    try {
+        const payload = JSON.parse(text.slice(text.indexOf('\n') + 1));
+        if (typeof payload.name !== 'string')
+            return null;
+        return typeof payload.file === 'string'
+            ? { name: payload.name, file: payload.file }
+            : { name: payload.name };
+    }
+    catch {
+        return null;
+    }
+}
+const HOST_ONLY_KEYS = ['data', 'hostNotice'];
+function historyPayload(output) {
+    if (!output || typeof output !== 'object')
+        return output;
+    if (!HOST_ONLY_KEYS.some((key) => key in output))
+        return output;
+    const rest = { ...output };
+    for (const key of HOST_ONLY_KEYS)
+        delete rest[key];
+    return rest;
+}

package/dist-lib/lib/capabilities/usage-breakdown.d.ts

@@ -0,0 +1,27 @@
+import type { SystemPromptParts } from '../prompt.ts';
+export interface PromptDensity {
+    prose: number;
+    schema: number;
+    toolBlockTokens: number;
+}
+export declare function densityFor(modelName?: string | null): PromptDensity;
+export interface PromptUsageChars {
+    systemPrompt: number;
+    agentInstructions: number;
+    activeSkills: number;
+    toolSchemas: number;
+}
+export interface UsageBreakdown {
+    systemPrompt: number;
+    agentInstructions: number;
+    activeSkills: number;
+    tools: number;
+    conversation: number;
+    totalTokens: number;
+}
+export interface PromptUsagePartsInput {
+    system: SystemPromptParts;
+    toolSchemas?: ReadonlyArray<unknown> | undefined;
+}
+export declare function promptUsageParts({ system, toolSchemas }: PromptUsagePartsInput): PromptUsageChars;
+export declare function usageBreakdown(chars: PromptUsageChars, totalTokens?: number | null, modelName?: string | null): UsageBreakdown | null;