@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/toolResult.js

@@ -4,7 +4,8 @@ import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
 import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
-import { readFrameTrueMark, readFrameTrueMarkReading } from './ownKey.js';
+import { guardedRead, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, } from './ownKey.js';
+import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
@@ -356,7 +357,8 @@ const killedBySignalSentence = (killCauseOf) => {
     }
     return TOOL_KILL_TEXT[isToolKillCause(cause) ? cause : 'unknown'];
 };
-export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured, leaderLedger = true, killCauseOf) {
+export function wireOutputToBody(toolName, output, isError, truncated, flatten, structuredIn, leaderLedger = true, killCauseOf) {
+    const structured = ownSnapshotWhenTyped(structuredIn, 'task-output');
     const text = flatten(output);
     const name = (toolName || '').toLowerCase();
     const sType = structuredDetailType(structured);
@@ -473,9 +475,12 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
     return { content: truncated ? `${text}\n…(truncated)` : text, isError };
 }
 export function structuredToToolUseResult(structured, modelText, leaderLedger = true) {
-    if (typeof structured !== 'object' || structured === null)
+    const sampled = ownSnapshotWhenTyped(structured, 'task-output');
+    if (typeof sampled !== 'object' || sampled === null)
         return null;
-    const s = structured;
+    const s = sampled;
+    if (guardedRead(() => readOwnDataValue(s, 'type')) === 'web-search')
+        return webSearchToolUseResult(s);
     for (const k of ['originalFile', 'content', 'stdout', 'stderr']) {
         if (typeof s[k] === 'string' && s[k].length > MAX_STRUCTURED_FIELD_CHARS)
             return null;
@@ -748,6 +753,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                 : (parsed?.status ?? (engineSaidNotReady ? 'running' : 'unknown'));
             const bodyText = hasContent ? s.content : parsed && parsed.kind !== 'unknown' ? parsed.output : undefined;
             const error = typeof s.error === 'string' ? s.error : undefined;
+            const completionId = terminalCardCompletionIdOf(s, engineSaidNotReady);
             if (taskType === 'background_bash') {
                 const exitCode = typeof inner?.exitCode === 'number' ? inner.exitCode : undefined;
                 return {
@@ -761,6 +767,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                             output: bodyText ?? '',
                             ...(exitCode !== undefined ? { exitCode } : {}),
                             ...(error !== undefined ? { error } : {}),
+                            ...(completionId !== undefined ? { _sema_completion_id: completionId } : {}),
                         },
                     },
                 };
@@ -777,6 +784,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                             output: bodyText ?? '',
                             result: bodyText ?? '',
                             ...(error !== undefined ? { error } : {}),
+                            ...(completionId !== undefined ? { _sema_completion_id: completionId } : {}),
                         },
                     },
                 };
@@ -801,6 +809,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                         output,
                         ...(error !== undefined ? { error } : {}),
                         ...(runErrorCode !== undefined ? { _sema_error_code: runErrorCode } : {}),
+                        ...(completionId !== undefined ? { _sema_completion_id: completionId } : {}),
                     },
                 },
             };
@@ -809,7 +818,143 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
             return null;
     }
 }
-export function detectEngineBgShellReceipt(toolName, rawInput, outputText, structured) {
+const WEB_SEARCH_ENTRIES_MAX = 1024;
+const WEB_SEARCH_HITS_MAX = 4096;
+const WEB_SEARCH_FIELD_CHARS_MAX = 8192;
+function isArrayLength(n) {
+    return Number.isInteger(n) && n >= 0 && n <= 4_294_967_295;
+}
+function isWebSearchRecord(v) {
+    return typeof v === 'object' && v !== null && guardedRead(() => !Array.isArray(v)) === true;
+}
+function readWebSearchHit(raw) {
+    if (!isWebSearchRecord(raw))
+        return undefined;
+    const title = readOwnDataValue(raw, 'title');
+    const url = readOwnDataValue(raw, 'url');
+    if (typeof title !== 'string' || typeof url !== 'string' || url === '')
+        return undefined;
+    if (title.length > WEB_SEARCH_FIELD_CHARS_MAX || url.length > WEB_SEARCH_FIELD_CHARS_MAX)
+        return undefined;
+    return { title, url };
+}
+function readWebSearchEntry(raw, hitBudget) {
+    if (!isWebSearchRecord(raw))
+        return undefined;
+    const toolUseId = readOwnDataValue(raw, 'tool_use_id');
+    const content = readOwnDataValue(raw, 'content');
+    if (typeof toolUseId !== 'string' || typeof content !== 'object' || content === null || !Array.isArray(content))
+        return undefined;
+    const n = readOwnDataFiniteNumber(content, 'length');
+    if (n === undefined || !isArrayLength(n))
+        return undefined;
+    const limit = Math.min(n, Math.max(0, hitBudget));
+    const hits = [];
+    let dropped = n - limit;
+    for (let j = 0; j < limit; j++) {
+        const hit = guardedRead(() => readWebSearchHit(readOwnDataValue(content, String(j))));
+        if (hit === undefined)
+            dropped++;
+        else
+            hits.push(hit);
+    }
+    return { entry: { tool_use_id: toolUseId, content: hits }, visited: limit, dropped };
+}
+function readWebSearchEntries(card) {
+    const results = guardedRead(() => readOwnDataValue(card, 'results'));
+    if (typeof results !== 'object' || results === null || guardedRead(() => Array.isArray(results)) !== true)
+        return undefined;
+    const length = guardedRead(() => readOwnDataFiniteNumber(results, 'length'));
+    if (length === undefined || !isArrayLength(length))
+        return undefined;
+    const entries = [];
+    let dropped = Math.max(0, length - WEB_SEARCH_ENTRIES_MAX);
+    let hitsLeft = WEB_SEARCH_HITS_MAX;
+    for (let i = 0; i < Math.min(length, WEB_SEARCH_ENTRIES_MAX); i++) {
+        const raw = guardedRead(() => readOwnDataValue(results, String(i)));
+        if (typeof raw === 'string') {
+            entries.push(raw);
+            continue;
+        }
+        const one = guardedRead(() => readWebSearchEntry(raw, hitsLeft));
+        if (one === undefined) {
+            dropped++;
+            continue;
+        }
+        entries.push(one.entry);
+        hitsLeft -= one.visited;
+        dropped += one.dropped;
+    }
+    const usable = entries.some(e => typeof e !== 'string' && e.content.length > 0);
+    if (dropped > 0 && !usable)
+        return undefined;
+    return { entries, dropped };
+}
+function webSearchToolUseResult(card) {
+    try {
+        const query = readOwnDataValue(card, 'query');
+        const durationSeconds = readOwnDataFiniteNumber(card, 'durationSeconds');
+        if (typeof query !== 'string' || durationSeconds === undefined || durationSeconds < 0)
+            return null;
+        const read = readWebSearchEntries(card);
+        if (read === undefined)
+            return null;
+        const searchCount = readOwnDataFiniteNumber(card, 'searchCount');
+        return {
+            toolUseResult: {
+                query,
+                results: read.entries.map(e => (typeof e === 'string' ? e : { tool_use_id: e.tool_use_id, content: e.content.map(h => ({ title: h.title, url: h.url })) })),
+                durationSeconds,
+                ...(searchCount !== undefined && Number.isInteger(searchCount) && searchCount >= 0 ? { searchCount } : {}),
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function webSearchSourcesOf(toolEnd) {
+    try {
+        if (!isWebSearchRecord(toolEnd))
+            return undefined;
+        const structured = readOwnDataValue(toolEnd, 'structured');
+        if (!isWebSearchRecord(structured) || readOwnDataValue(structured, 'type') !== 'web-search')
+            return undefined;
+        const read = readWebSearchEntries(structured);
+        if (read === undefined)
+            return undefined;
+        let dropped = read.dropped;
+        const out = [];
+        for (const e of read.entries) {
+            if (typeof e === 'string')
+                continue;
+            for (const h of e.content) {
+                const url = guardedRead(() => displayUntrusted(h.url));
+                const title = guardedRead(() => displayUntrusted(h.title));
+                if (url === undefined || url === '' || title === undefined)
+                    dropped++;
+                else
+                    out.push(Object.freeze({ title, url }));
+            }
+        }
+        if (out.length === 0 && dropped > 0)
+            return undefined;
+        Object.defineProperty(out, 'droppedCount', { value: dropped, enumerable: false });
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
+function terminalCardCompletionIdOf(s, engineSaidNotReady) {
+    if (engineSaidNotReady)
+        return undefined;
+    const status = guardedRead(() => readOwnDataNonEmptyString(s, 'status'));
+    if (!isCoreSemaTaskTerminal(status))
+        return undefined;
+    return guardedRead(() => readOwnDataNonEmptyString(s, 'completionId'));
+}
+export function detectEngineBgShellReceipt(toolName, rawInput, outputText, structured, toolUseId) {
     if (typeof outputText !== 'string')
         return null;
     const input = (rawInput ?? {});
@@ -832,28 +977,30 @@ export function detectEngineBgShellReceipt(toolName, rawInput, outputText, struc
     }
     if (!m?.[1])
         return null;
-    return engineBgShellRegistrationBody(m[1], input, outputText, source);
+    return engineBgShellRegistrationBody(m[1], input, outputText, source, toolUseId, undefined);
 }
-function engineBgShellRegistrationBody(taskId, rawInput, receipt, source) {
+function engineBgShellRegistrationBody(taskId, rawInput, receipt, source, toolUseId, outputFile) {
     const input = (rawInput ?? {});
     const command = typeof input.command === 'string' ? input.command : '(engine bash)';
     const description = typeof input.description === 'string' ? input.description : undefined;
     return {
         kind: 'register',
         taskId,
+        ...(typeof toolUseId === 'string' && toolUseId.length > 0 ? { toolUseId } : {}),
         command,
         ...(description !== undefined ? { description } : {}),
         receipt,
+        ...(typeof outputFile === 'string' && outputFile.length > 0 ? { outputFile } : {}),
         source,
     };
 }
-export function detectEngineBgShellDetach(toolName, rawInput, structured, outputText) {
+export function detectEngineBgShellDetach(toolName, rawInput, structured, outputText, toolUseId) {
     if (toolName !== 'Bash')
         return null;
     const view = readBashDetachView(structured);
     if (view === null || view.registerFailed || view.handoffTaskId === undefined)
         return null;
-    return engineBgShellRegistrationBody(view.handoffTaskId, rawInput, typeof outputText === 'string' ? outputText : '', 'bash');
+    return engineBgShellRegistrationBody(view.handoffTaskId, rawInput, typeof outputText === 'string' ? outputText : '', 'bash', toolUseId, view.outputFile);
 }
 function readBashDetachView(structured) {
     if (typeof structured !== 'object' || structured === null)
@@ -865,9 +1012,11 @@ function readBashDetachView(structured) {
     const detached = s.detached;
     const registerFailed = s.registerFailed;
     const taskId = s.task_id;
+    const outputFile = s.output_file;
     return {
         handoffTaskId: detached === true && typeof taskId === 'string' && taskId.length > 0 ? taskId : undefined,
         registerFailed: registerFailed === true,
+        outputFile: typeof outputFile === 'string' && outputFile.length > 0 ? outputFile : undefined,
     };
 }
 export function todoWriteToolUseResult(rawInput, oldTodos, isError) {

package/dist/toolResultContent.d.ts

@@ -1,2 +1,15 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export type ToolOutputMediaAbsence = {
+    readonly kind: 'descriptor';
+    readonly mediaType: 'image' | 'document';
+    readonly mimeType?: string;
+    readonly bytes: number;
+} | {
+    readonly kind: 'omitted';
+    readonly blocks: number;
+    readonly bytes: number;
+};
+export declare function toolOutputMediaAbsenceOf(block: object | null | undefined): ToolOutputMediaAbsence | undefined;
+export declare function toolOutputMediaAbsenceSentence(view: ToolOutputMediaAbsence | null | undefined, lang?: UiLanguage): string;
 export declare function toolResultBlocksOf(output: unknown, truncated: boolean): unknown[] | undefined;
 export declare function toolEndOutputText(output: unknown): string | undefined;

package/dist/toolResultContent.js

@@ -1,12 +1,78 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { readOwnDataValue } from './ownKey.js';
 const IMAGE_MEDIA_TYPES = Object.freeze(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
 const OMITTED_CONTENT_NOTE = '[unsupported content omitted]';
 const IMAGE_TEXT_PLACEHOLDER = '[image]';
+const ECHOABLE_MIME_TYPE = /^[\x21-\x7e][\x20-\x7e]{0,254}$/;
+function countOf(v, min) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= min ? (v === 0 ? 0 : v) : undefined;
+}
+function mimeTypeSlot(o) {
+    return Object.hasOwn(o, 'mimeType') ? (readOwnDataValue(o, 'mimeType') ?? null) : undefined;
+}
+function mintAbsence(kind, mediaType, mimeType, blocks, bytes) {
+    const size = countOf(bytes, 0);
+    if (size === undefined)
+        return undefined;
+    if (kind === 'omitted') {
+        const n = countOf(blocks, 1);
+        return n === undefined ? undefined : Object.freeze({ kind: 'omitted', blocks: n, bytes: size });
+    }
+    if (kind !== 'descriptor' || (mediaType !== 'image' && mediaType !== 'document'))
+        return undefined;
+    if (mimeType !== undefined && typeof mimeType !== 'string')
+        return undefined;
+    return Object.freeze(typeof mimeType === 'string' && ECHOABLE_MIME_TYPE.test(mimeType) ? { kind, mediaType, mimeType, bytes: size } : { kind, mediaType, bytes: size });
+}
+export function toolOutputMediaAbsenceOf(block) {
+    try {
+        if (typeof block !== 'object' || block === null || Array.isArray(block))
+            return undefined;
+        if (readOwnDataValue(block, 'truncated') !== true)
+            return undefined;
+        const type = readOwnDataValue(block, 'type');
+        const bytes = readOwnDataValue(block, 'bytes');
+        if (type === 'omitted')
+            return mintAbsence('omitted', undefined, undefined, readOwnDataValue(block, 'blocks'), bytes);
+        if (type !== 'image' && type !== 'document')
+            return undefined;
+        if ('data' in block)
+            return undefined;
+        return mintAbsence('descriptor', type, mimeTypeSlot(block), undefined, bytes);
+    }
+    catch {
+        return undefined;
+    }
+}
+function absenceRefOf(a) {
+    if (a.kind === 'omitted') {
+        return msg(a.blocks === 1 ? 'session.toolResult.media.notDelivered.omitted.one' : 'session.toolResult.media.notDelivered.omitted.other', { blocks: a.blocks, bytes: a.bytes });
+    }
+    const kind = msg(a.mediaType === 'image' ? 'session.toolResult.media.kind.image' : 'session.toolResult.media.kind.document');
+    return a.mimeType === undefined
+        ? msg('session.toolResult.media.notDelivered.descriptorNoMime', { kind, bytes: a.bytes })
+        : msg('session.toolResult.media.notDelivered.descriptor', { kind, mimeType: a.mimeType, bytes: a.bytes });
+}
+export function toolOutputMediaAbsenceSentence(view, lang) {
+    try {
+        if (typeof view !== 'object' || view === null || Array.isArray(view))
+            return '';
+        const a = mintAbsence(readOwnDataValue(view, 'kind'), readOwnDataValue(view, 'mediaType'), mimeTypeSlot(view), readOwnDataValue(view, 'blocks'), readOwnDataValue(view, 'bytes'));
+        return a === undefined ? '' : renderMessage(absenceRefOf(a), lang);
+    }
+    catch {
+        return '';
+    }
+}
 function blockOf(raw) {
     if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
         return null;
     const b = raw;
     if (b.type === 'text')
-        return typeof b.text === 'string' ? { type: 'text', text: b.text } : null;
+        return typeof b.text === 'string' ? { block: { type: 'text', text: b.text }, undelivered: false } : null;
+    const absence = toolOutputMediaAbsenceOf(b);
+    if (absence !== undefined)
+        return { block: { type: 'text', text: renderMessage(absenceRefOf(absence)) }, undelivered: true };
     if (b.type !== 'image')
         return null;
     const data = b.data;
@@ -15,7 +81,7 @@ function blockOf(raw) {
         return null;
     if (typeof mediaType !== 'string' || !IMAGE_MEDIA_TYPES.includes(mediaType))
         return null;
-    return { type: 'image', source: { type: 'base64', media_type: mediaType, data } };
+    return { block: { type: 'image', source: { type: 'base64', media_type: mediaType, data } }, undelivered: false };
 }
 const TRUNCATED_NOTE = '…(truncated)';
 function toolResultContentOf(output) {
@@ -26,17 +92,26 @@ function toolResultContentOf(output) {
     const blocks = [];
     let omitted = 0;
     let images = 0;
+    let undelivered = 0;
     for (const raw of output) {
-        const block = blockOf(raw);
-        if (block === null)
+        let read = null;
+        try {
+            read = blockOf(raw);
+        }
+        catch {
+            read = null;
+        }
+        if (read === null)
             omitted++;
         else {
-            if (block.type === 'image')
+            if (read.block.type === 'image')
                 images++;
-            blocks.push(block);
+            if (read.undelivered)
+                undelivered++;
+            blocks.push(read.block);
         }
     }
-    if (images === 0 && omitted === 0)
+    if (images === 0 && omitted === 0 && undelivered === 0)
         return blocks.map((b) => b.text).join('');
     if (omitted > 0)
         blocks.push({ type: 'text', text: OMITTED_CONTENT_NOTE });

package/dist/toolRoster.d.ts

@@ -83,6 +83,7 @@ export declare function handsMountedDetail(reading: HandsMountedReading, lang?:
 export declare function toolRosterNames(roster: ToolRosterView | undefined): readonly string[];
 export interface ToolShim {
     name: string;
+    aliases?: readonly string[];
     source: string;
     family?: string;
     userFacingName?: string;
@@ -97,6 +98,23 @@ export interface ToolShim {
     capabilityId?: string;
 }
 export declare function toolShimFromRoster(entry: unknown): ToolShim | undefined;
+export interface EngineRosterPeerTool {
+    name: string;
+    aliases?: readonly string[];
+    cardId?: string;
+}
+export interface EngineRosterPeerGroup {
+    peer: string;
+    declaredBy?: readonly string[];
+    tools: readonly EngineRosterPeerTool[];
+    count: number;
+}
+export interface EngineRosterPeersView {
+    groups: readonly EngineRosterPeerGroup[];
+    unattributed: readonly EngineRosterPeerTool[];
+}
+export declare function projectEngineRosterPeers(roster: ToolRosterView | undefined, source: string): EngineRosterPeersView | undefined;
+export declare function projectEngineA2aPeers(roster: ToolRosterView | undefined): EngineRosterPeersView | undefined;
 export interface ToolRosterDeltaApplication {
     roster: ToolRosterView | undefined;
     applied: boolean;

package/dist/toolRoster.js

@@ -205,6 +205,7 @@ export function toolShimFromRoster(entry) {
     return {
         name: e.name,
         source: e.source,
+        ...(e.aliases !== undefined ? { aliases: copyStrings(e.aliases) } : {}),
         ...(e.family !== undefined ? { family: e.family } : {}),
         ...(e.renderHints?.userFacingName !== undefined ? { userFacingName: e.renderHints.userFacingName } : {}),
         ...(e.renderHints?.activity !== undefined ? { activity: e.renderHints.activity } : {}),
@@ -218,6 +219,69 @@ export function toolShimFromRoster(entry) {
         ...(e.capabilityId !== undefined ? { capabilityId: e.capabilityId } : {}),
     };
 }
+const compareCodeUnits = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+function copyStrings(src) {
+    const out = [];
+    const n = src.length;
+    for (let i = 0; i < n; i++) {
+        const v = src[i];
+        if (typeof v === 'string')
+            out.push(v);
+    }
+    return out;
+}
+function rosterPeerToolOf(e) {
+    return {
+        name: e.name,
+        ...(e.aliases !== undefined ? { aliases: copyStrings(e.aliases) } : {}),
+        ...(e.cardId !== undefined ? { cardId: e.cardId } : {}),
+    };
+}
+export function projectEngineRosterPeers(roster, source) {
+    if (typeof roster !== 'object' || roster === null)
+        return undefined;
+    if (typeof source !== 'string' || source.length === 0)
+        return undefined;
+    try {
+        const view = readRoster(roster);
+        if (view === undefined || view.entries.length !== view.count)
+            return undefined;
+        const slots = new Map();
+        const unattributed = [];
+        for (const e of view.entries) {
+            if (e.source !== source)
+                continue;
+            const peer = e.origin?.peer;
+            if (peer === undefined) {
+                unattributed.push(rosterPeerToolOf(e));
+                continue;
+            }
+            let slot = slots.get(peer);
+            if (slot === undefined) {
+                slot = { tools: [], declaredBy: new Set() };
+                slots.set(peer, slot);
+            }
+            slot.tools.push(rosterPeerToolOf(e));
+            if (e.origin?.declaredBy !== undefined)
+                slot.declaredBy.add(e.origin.declaredBy);
+        }
+        const groups = [...slots.entries()]
+            .sort((a, b) => compareCodeUnits(a[0], b[0]))
+            .map(([peer, slot]) => ({
+            peer,
+            ...(slot.declaredBy.size > 0 ? { declaredBy: [...slot.declaredBy].sort(compareCodeUnits) } : {}),
+            tools: slot.tools,
+            count: slot.tools.length,
+        }));
+        return { groups, unattributed };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectEngineA2aPeers(roster) {
+    return projectEngineRosterPeers(roster, 'a2a');
+}
 function readSummary(raw) {
     const o = obj(raw);
     if (o === undefined)

package/dist/toolsFlagNames.d.ts

@@ -0,0 +1,8 @@
+export interface ToolsFlagNames {
+    readonly kept: readonly string[];
+    readonly excluded: readonly string[];
+    readonly bare: boolean;
+    readonly detached: readonly string[];
+    readonly scoped: readonly string[];
+}
+export declare function parseToolsFlagNames(values: readonly string[]): ToolsFlagNames;

package/dist/toolsFlagNames.js

@@ -0,0 +1,110 @@
+function readableStrings(values) {
+    const out = [];
+    try {
+        if (!Array.isArray(values))
+            return out;
+        const n = values.length;
+        for (let i = 0; i < n; i++) {
+            try {
+                const v = values[i];
+                if (typeof v === 'string')
+                    out.push(v);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return out;
+    }
+    return out;
+}
+function splitToolsFlagTokens(values) {
+    const out = [];
+    for (const value of values) {
+        if (value === '')
+            continue;
+        let cur = '';
+        let inParen = false;
+        for (const ch of value) {
+            if (ch === '(') {
+                inParen = true;
+                cur += ch;
+            }
+            else if (ch === ')') {
+                inParen = false;
+                cur += ch;
+            }
+            else if (ch === ',') {
+                if (inParen)
+                    cur += ch;
+                else {
+                    if (cur.trim() !== '')
+                        out.push(cur.trim());
+                    cur = '';
+                }
+            }
+            else if (ch === ' ') {
+                if (inParen)
+                    cur += ch;
+                else if (cur.trim() !== '') {
+                    out.push(cur.trim());
+                    cur = '';
+                }
+            }
+            else if (cur !== '' || ch.trim() !== '') {
+                cur += ch;
+            }
+        }
+        if (cur.trim() !== '')
+            out.push(cur.trim());
+    }
+    return out;
+}
+export function parseToolsFlagNames(values) {
+    const tokens = splitToolsFlagTokens(readableStrings(values));
+    const kept = [];
+    const excluded = new Set();
+    const detached = [];
+    const scoped = [];
+    let bare = false;
+    for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        if (token === undefined)
+            continue;
+        if (!token.startsWith('!')) {
+            kept.push(token);
+            continue;
+        }
+        let name = token.slice(1);
+        if (name === '') {
+            const next = tokens[i + 1];
+            if (next === undefined || next.startsWith('!') || next.startsWith('(')) {
+                bare = true;
+                continue;
+            }
+            i++;
+            detached.push(next);
+            token = `!${next}`;
+            name = next;
+        }
+        const paren = name.indexOf('(');
+        if (paren === 0) {
+            bare = true;
+            continue;
+        }
+        if (paren > 0) {
+            name = name.slice(0, paren);
+            scoped.push(token);
+        }
+        excluded.add(name);
+    }
+    return Object.freeze({
+        kept: Object.freeze(kept),
+        excluded: Object.freeze([...excluded]),
+        bare,
+        detached: Object.freeze(detached),
+        scoped: Object.freeze(scoped),
+    });
+}