@sema-agent/client-core 0.88.0 → 0.89.0

package/dist/controlRouter.d.ts

@@ -17,7 +17,7 @@ export interface RunsResourceLike {
 export interface ControlClientLike {
     runs: RunsResourceLike;
 }
-export type ControlSafetyCode = 'not_running' | 'invalid_content' | 'queue_full' | 'duplicate_input_id' | 'ambiguous_target' | 'still_running' | 'blocked_by_hook' | 'steering_other' | 'cancel_lost_race' | 'cancel_run_not_running' | 'not_found';
+export type ControlSafetyCode = 'not_running' | 'invalid_content' | 'queue_full' | 'duplicate_input_id' | 'ambiguous_target' | 'still_running' | 'blocked_by_hook' | 'ledger_unavailable' | 'steering_other' | 'cancel_lost_race' | 'cancel_run_not_running' | 'not_found';
 export declare class ControlSafetyError extends Error {
     readonly code: ControlSafetyCode;
     readonly cause?: unknown | undefined;
@@ -71,3 +71,9 @@ export interface ErrCodes {
     status?: number | undefined;
 }
 export declare function errCodes(e: unknown): ErrCodes;
+export declare function steeringStatusIs4xx(e: object): boolean;
+export interface SteeringRefusedBeforeEngine {
+    safety: ControlSafetyCode;
+    advice: string;
+}
+export declare function steeringRefusedBeforeEngine(e: object): SteeringRefusedBeforeEngine | undefined;

package/dist/controlRouter.js

@@ -64,8 +64,9 @@ export class ControlRouter {
         catch (e) {
             const verdict = steeringVerdict(e);
             if (verdict !== undefined) {
+                const safety = steeringSafetyOf(e, verdict);
                 const wireCode = errCodes(e).code ?? errCodes(e).name ?? 'steering.<unknown>';
-                throw new ControlSafetyError(`${wireCode} — ${STEERING_ADVICE.get(verdict) ?? 'steering refused'}`, verdict, e);
+                throw new ControlSafetyError(`${wireCode} — ${steeringAdviceOf(e, safety) ?? 'steering refused'}`, safety, e);
             }
             throw e;
         }
@@ -138,12 +139,14 @@ const STEERING_CODE_TO_SAFETY = new Map([
     ['steering.ambiguous_label', 'ambiguous_target'],
     ['steering.still_running', 'still_running'],
     ['steering.blocked_by_hook', 'blocked_by_hook'],
+    ['steering.ledger_unavailable', 'ledger_unavailable'],
 ]);
 const STEERING_NAME_TO_SAFETY = new Map([
     ['SteeringNotRunningError', 'not_running'],
     ['SteeringInvalidContentError', 'invalid_content'],
     ['SteeringAmbiguousTargetError', 'ambiguous_target'],
     ['SteeringStillRunningError', 'still_running'],
+    ['SteeringLedgerUnavailableError', 'ledger_unavailable'],
     ['SteeringError', 'steering_other'],
 ]);
 const STEERING_ADVICE = new Map([
@@ -154,8 +157,47 @@ const STEERING_ADVICE = new Map([
     ['ambiguous_target', 'more than one live target matches — address it uniquely (sub-agent: parentToolCallId; workflow: a more specific label); retrying verbatim yields the same result'],
     ['still_running', 'the target is STILL RUNNING — steer it instead of resuming, or wait for it to settle (this is the exact opposite of not_running: never collapse the two)'],
     ['blocked_by_hook', "this deployment's userPromptSubmit gate refused the input (block, timeout and crash all report this one code, fail-closed) — the input was NOT accepted: no human_input frame, the inputId is not on the ledger, so editing the text and sending again is a normal retry, not a duplicate"],
+    ['ledger_unavailable', 'the server could not record this steer in its user-input ledger and refused it before anything reached the engine — the input was NOT delivered; resend the same text later (the same Idempotency-Key is fine)'],
     ['steering_other', 'an unrecognized steering.* refusal (open set) — the steer did NOT land; log the errorCode verbatim, do not guess its meaning'],
 ]);
+const STEERING_OTHER_UNKNOWN_ADVICE = 'an unrecognized steering.* refusal (open set) — treat delivery as unknown (do not resend as if it had certainly been dropped); log the errorCode verbatim, do not guess its meaning';
+export function steeringStatusIs4xx(e) {
+    let status;
+    try {
+        status = errCodes(e).status;
+    }
+    catch {
+        return false;
+    }
+    return status !== undefined && status >= 400 && status < 500;
+}
+function steeringAdviceOf(e, safety) {
+    if (safety === 'steering_other' && !(typeof e === 'object' && e !== null && steeringStatusIs4xx(e)))
+        return STEERING_OTHER_UNKNOWN_ADVICE;
+    return STEERING_ADVICE.get(safety);
+}
+const STEERING_REFUSED_BEFORE_ENGINE = new Map([['ledger_unavailable', 503]]);
+export function steeringRefusedBeforeEngine(e) {
+    try {
+        const { status } = errCodes(e);
+        if (status === undefined)
+            return undefined;
+        const safety = steeringVerdict(e);
+        if (safety === undefined || STEERING_REFUSED_BEFORE_ENGINE.get(safety) !== status)
+            return undefined;
+        const advice = STEERING_ADVICE.get(safety);
+        return advice === undefined ? undefined : { safety, advice };
+    }
+    catch {
+        return undefined;
+    }
+}
+function steeringSafetyOf(e, verdict) {
+    if (!STEERING_REFUSED_BEFORE_ENGINE.has(verdict))
+        return verdict;
+    const refused = typeof e === 'object' && e !== null ? steeringRefusedBeforeEngine(e) : undefined;
+    return refused !== undefined && refused.safety === verdict ? verdict : 'steering_other';
+}
 function steeringVerdict(e) {
     const { code, name } = errCodes(e);
     if (typeof code === 'string' && code.startsWith('steering.')) {

package/dist/disableSkillsWire.d.ts

@@ -0,0 +1,17 @@
+export declare function refuseBadDisableSkills(v: unknown, who: string): void;
+export declare function refuseDisableSkillsConflict(disableSkills: unknown, skills: unknown, agents: unknown, who: string): void;
+type DisableSkillsWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
+export type DisableSkillsDeclaration = {
+    readonly field: {
+        readonly disableSkills: true;
+    };
+    readonly withheld?: undefined;
+} | {
+    readonly field: Readonly<Record<string, never>>;
+    readonly withheld?: {
+        readonly cause: DisableSkillsWithheldCause;
+        readonly text: string;
+    };
+};
+export declare function disableSkillsDeclaration(want: unknown, baseUrl: string | undefined): DisableSkillsDeclaration;
+export {};

package/dist/disableSkillsWire.js

@@ -0,0 +1,52 @@
+import { engineCapState } from './engineCapsCache.js';
+const KEY = 'disableSkills';
+const shapeOf = (v) => {
+    try {
+        return v === null ? 'null' : Array.isArray(v) ? 'typeof=object / array' : typeof v === 'string' ? `typeof=string(长 ${v.length})` : `typeof=${typeof v}`;
+    }
+    catch {
+        return `typeof=${typeof v} / unreadable`;
+    }
+};
+export function refuseBadDisableSkills(v, who) {
+    if (v === undefined || v === null || v === true || v === false)
+        return;
+    throw new TypeError(`${who}: disableSkills 只接受布尔或缺席(undefined/null)—— 收到 ${shapeOf(v)}。` +
+        '这一位是「这一发一只技能都不装」的声明:本层若把坏值折成缺席,这一次运行会照常装上技能而声明人不会知道;' +
+        '上游对非布尔值同样拒收。错误文本只报形状,不回显值。');
+}
+const nonEmptyArray = (v) => Array.isArray(v) && v.length > 0;
+const anyAgentCarriesSkills = (agents) => Array.isArray(agents) && agents.some((a) => typeof a === 'object' && a !== null && nonEmptyArray(a.skills));
+export function refuseDisableSkillsConflict(disableSkills, skills, agents, who) {
+    if (disableSkills !== true)
+        return;
+    const inSkills = nonEmptyArray(skills);
+    const inAgents = anyAgentCarriesSkills(agents);
+    if (!inSkills && !inAgents)
+        return;
+    const which = inSkills && inAgents ? 'skills 与 agents[].skills' : inSkills ? 'skills' : 'agents[].skills';
+    throw new TypeError(`${who}: disableSkills: true(这一发一只技能都不装)与非空的 ${which} 同在 —— 二选一:要关技能就别交技能,要交技能就别带 disableSkills。` +
+        '上游对这一组合同样拒收(在任何东西跑起来之前);本层在装配前拒,不让它走一次往返。错误文本只报键名,不回显技能名。');
+}
+const WITHHELD_TEXT = Object.freeze({
+    not_reported: 'Skills were not turned off for this request: the connected engine does not report that it can turn them off, and an engine that does not know this setting rejects the whole request, so the setting was left out and this run keeps its usual skills.',
+    unsupported: 'Skills were not turned off for this request: the connected engine reports that it cannot turn them off, so the setting was left out and this run keeps its usual skills.',
+    unprobed: 'Skills were not turned off for this request: what the connected engine supports has not been read yet, and an engine that does not know this setting rejects the whole request, so the setting was held back and this run keeps its usual skills.',
+    unreadable: 'Skills were not turned off for this request: the connected engine reported whether it can turn them off in a form this version cannot read, so the setting was left out and this run keeps its usual skills.',
+});
+const WITHHELD_CAUSE_OF = {
+    absent: 'not_reported',
+    false: 'unsupported',
+    unprobed: 'unprobed',
+    non_boolean: 'unreadable',
+};
+export function disableSkillsDeclaration(want, baseUrl) {
+    refuseBadDisableSkills(want, 'disableSkillsDeclaration');
+    if (want !== true)
+        return Object.freeze({ field: Object.freeze({}) });
+    const state = engineCapState(baseUrl, KEY);
+    if (state === 'true')
+        return Object.freeze({ field: Object.freeze({ disableSkills: true }) });
+    const cause = WITHHELD_CAUSE_OF[state];
+    return Object.freeze({ field: Object.freeze({}), withheld: Object.freeze({ cause, text: WITHHELD_TEXT[cause] }) });
+}

package/dist/displayUntrusted.js

@@ -66,7 +66,7 @@ const TEXT_BY_KIND = {
 };
 const isStructuralKind = (kind) => kind !== 'secret';
 const MARKER_WITH_DOTS = /^[. ]*(?:(?:\u00abredacted(?::[a-z-]{1,16}){0,2}\u00bb|\*{3})[. ]*)+$/;
-function valueIsWholeMarker(S, start, end) {
+function valueIsWholeMarker(S, start, end, tokenInner = true) {
     const text = S.text;
     let k = start;
     while (k < end && (S.dropped(k) || text[k] === '.' || text[k] === ' '))
@@ -92,11 +92,11 @@ function valueIsWholeMarker(S, start, end) {
     if (retired) {
         while (j < end && (S.dropped(j) || S.painted(j) || text[j] === '.' || text[j] === ' '))
             j++;
-        return j >= end || credentialWordStartsExactlyAt(text, j) || credentialPairAt(S, j);
+        return j >= end || credentialWordStartsExactlyAt(text, j, tokenInner) || credentialPairAt(S, j);
     }
     while (j < end && (S.dropped(j) || S.painted(j)))
         j++;
-    return j >= end || !isKeyWordChar(text.charCodeAt(j)) || credentialWordStartsExactlyAt(text, j) || credentialPairAt(S, j);
+    return j >= end || !isKeyWordChar(text.charCodeAt(j)) || credentialWordStartsExactlyAt(text, j, tokenInner) || credentialPairAt(S, j);
 }
 const CREDENTIAL_NAME = /(?:(?:access|refresh|id|client|api|x[-_]api|session|auth)[-_]?)?(?:token|key|secret|password|authorization|credential)s?|bearer|basic/iy;
 const LABEL_SEPARATOR = /(?:\\*["'])?[\s\u115F\u1160\u3164\uFFA0\u2800]*[:=\uFF1A\uFF1D]/y;
@@ -379,7 +379,7 @@ function urlCandidates(text, out, regions, unitPos = () => false, soft) {
                 let p = end;
                 while (p < text.length && (text[p] === VIEW_SEPARATOR || isUnicodeBlank(text.charCodeAt(p))))
                     p++;
-                if (credentialWordStartsNear(text, p))
+                if (nextPairBeyondFragmentAt(text, p))
                     break;
                 end = p;
                 continue;
@@ -759,7 +759,8 @@ const NAME_BLANK_RANGES = [
 const isNameBlank = (cp) => NAME_BLANK_RANGES.some(([a, b]) => cp >= a && cp <= b);
 const isFoldedBlank = (c) => isNameBlank(c) && isRegexSpace(c);
 const isUnicodeBlank = (c) => (c > 0x7f && isRegexSpace(c) && c !== 0xfeff) || isNameBlank(c);
-const SECRET_SCHEME_WORD = /(?:\b|(?<=\\[A-Za-z"']))(bearer|basic)[\s:=\uFF1A\uFF1D\u115F\u1160\u3164\uFFA0\u2800]+/gi;
+const SECRET_SCHEME_WORD = /(?:\b|(?<=\\[A-Za-z"']))(bearer|basic|token)[\s:=\uFF1A\uFF1D\u115F\u1160\u3164\uFFA0\u2800]+/gi;
+const schemeWordIsInner = (word, tokenInner) => tokenInner || word.toLowerCase() !== 'token';
 const SECRET_LABELLED_WORD = /(?:\b|(?<=_)|(?<=\\[A-Za-z"']))((?:access[-_ ]?|refresh[-_ ]?|id[-_ ]?|client[-_ ]?|api[-_ ]?|x[-_]api[-_ ]?|session[-_ ]?|auth[-_ ]?)?(?:token|key|secret|password|authorization|credential)s?)(?:\\*["'])?[\s\u115F\u1160\u3164\uFFA0\u2800]*[:=\uFF1A\uFF1D][\s\u115F\u1160\u3164\uFFA0\u2800]*/gi;
 const DIAGNOSTIC_VALUE_WORDS = new Set([
     'missing', 'required', 'invalid', 'expired', 'unauthorized', 'unauthenticated', 'authentication',
@@ -777,6 +778,37 @@ const SCHEME_FOLLOWER_WORDS = new Set([
     'setup', 'plan', 'tier', 'info', 'information', 'support', 'level', 'string', 'config', 'configuration', 'settings',
     'version', 'check', 'validation', 'error', 'errors', 'failed', 'failure', 'credentials', 'user', 'username',
 ]);
+const TOKEN_FOLLOWER_WORDS = new Set([
+    ...SCHEME_FOLLOWER_WORDS,
+    'count', 'counts', 'counting', 'counter', 'counters', 'limit', 'limits', 'budget', 'budgets', 'window', 'windows', 'estimate', 'estimates',
+    'estimation', 'estimator', 'length', 'size', 'cost', 'costs', 'price', 'pricing', 'rate', 'rates', 'quota', 'quotas', 'cap', 'caps', 'ceiling',
+    'threshold', 'total', 'totals', 'accounting', 'allocation', 'consumption', 'overflow', 'savings', 'reduction', 'spend', 'metrics', 'stats',
+    'boundary', 'boundaries', 'stream', 'streaming', 'position', 'positions', 'index', 'offset', 'probability', 'probabilities', 'logprob',
+    'logprobs', 'sequence', 'encoding', 'tokenizer', 'vocabulary', 'id', 'ids', 'maximum', 'minimum', 'max', 'min', 'ratio', 'table', 'line',
+    'lines', 'unit', 'units', 'indices',
+    'refresh', 'refreshed', 'refreshes', 'refreshing', 'exchange', 'exchanged', 'endpoint', 'endpoints', 'request', 'requests', 'response',
+    'responses', 'store', 'stored', 'storage', 'cache', 'cached', 'caching', 'file', 'files', 'path', 'dir', 'directory', 'source', 'provider',
+    'providers', 'supplier', 'helper', 'command', 'env', 'environment', 'variable', 'lifetime', 'ttl', 'expiry', 'expiration', 'expires', 'expiring',
+    'rotation', 'rotated', 'revocation', 'revoke', 'introspection', 'verification', 'verified', 'generation', 'generated', 'issuer', 'issued',
+    'audience', 'claims', 'scope', 'scopes', 'permission', 'permissions', 'owner', 'name', 'label', 'hash', 'signature', 'payload', 'body',
+    'cookie', 'kind', 'types', 'data', 'metadata', 'envelope', 'binding', 'bound', 'renewal', 'minted', 'acquired', 'fetch', 'fetched', 'parsing',
+    'parse', 'parsed', 'persisted', 'url', 'urls', 'client', 'argument', 'flag', 'option', 'field', 'governance', 'target',
+    'has', 'have', 'had', 'will', 'would', 'could', 'may', 'might', 'does', 'did', 'do', 'doesn', 'isn', 'wasn', 'hasn', 'didn', 'won', 'couldn',
+    'wouldn', 'shouldn', 'aren', 'weren', 'haven', 'been', 'being', 'needs', 'need', 'appears', 'seems', 'looks', 'lives', 'stays', 'remains',
+    'starts', 'stopped', 'closed', 'arrived', 'surfaced', 'vanished', 'belongs', 'carries', 'contains', 'lacks', 'matches', 'match', 'changed',
+    'created', 'deleted', 'removed', 'updated', 'exceeded', 'exceeds', 'exhausted', 'reached', 'returned', 'returns', 'received', 'provided',
+    'supplied', 'found', 'used', 'using', 'saved', 'loaded', 'accepted', 'validated', 'passed', 'sent', 'fails', 'works', 'already', 'still',
+    'also', 'only', 'never', 'now', 'here', 'there', 'then', 'than', 'so', 'but', 'as', 'if', 'when', 'while', 'until', 'before', 'after',
+    'since', 'because', 'via', 'into', 'over', 'under', 'within', 'without', 'per', 'each', 'every', 'any', 'all', 'its', 'which', 'whose',
+    'please', 'run', 'try', 'retry', 'see', 'use', 'visit', 'reauthenticate', 'reconnect',
+]);
+function schemeFollowerReleased(scheme, value, afterPathSlash) {
+    const word = value.replace(/[.,;:!?)]+$/, '').toLowerCase();
+    const isToken = scheme.toLowerCase() === 'token';
+    if (isToken && afterPathSlash && /^\d{3}$/.test(word))
+        return true;
+    return (isToken ? TOKEN_FOLLOWER_WORDS : SCHEME_FOLLOWER_WORDS).has(word);
+}
 const AUTH_SCHEME_WORDS = new Set([
     'bearer', 'basic', 'digest', 'token', 'bot', 'ssws', 'api-key', 'apikey', 'key', 'hmac', 'oauth', 'oauth2', 'jwt',
     'negotiate', 'ntlm', 'hawk', 'mac', 'dsn', 'splunk', 'sapisidhash', 'googlelogin', 'aws', 'client-id', 'pat',
@@ -786,9 +818,11 @@ const BARE_VALUE_STOP_CHARS = new Set([',', ';', '"', "'", '\\', '(', ')', '[',
 const isBareValueStop = (ch) => ch <= ' ' || BARE_VALUE_STOP_CHARS.has(ch);
 class InnerWordIndex {
     text;
+    tokenInner;
     probes;
-    constructor(text) {
+    constructor(text, tokenInner = true) {
         this.text = text;
+        this.tokenInner = tokenInner;
         this.probes = [
             { re: new RegExp(SECRET_LABELLED_WORD.source, SECRET_LABELLED_WORD.flags), scheme: false, from: -1, hit: null },
             { re: new RegExp(SECRET_SCHEME_WORD.source, SECRET_SCHEME_WORD.flags), scheme: true, from: -1, hit: null },
@@ -800,7 +834,11 @@ class InnerWordIndex {
             const reusable = p.from !== -1 && q >= p.from && (p.hit === null || q <= p.hit.start);
             if (!reusable) {
                 p.re.lastIndex = q;
-                const m = p.re.exec(this.text);
+                let m = p.re.exec(this.text);
+                while (m !== null && p.scheme && !schemeWordIsInner(m[1] ?? '', this.tokenInner)) {
+                    p.re.lastIndex = m.index + 1;
+                    m = p.re.exec(this.text);
+                }
                 p.from = q;
                 if (m === null)
                     p.hit = null;
@@ -885,7 +923,7 @@ function scanSecretValue(text, from, idx) {
             let p = j;
             while (p < text.length && text[p] === VIEW_SEPARATOR)
                 p++;
-            if (credentialWordStartsNear(text, p))
+            if (credentialWordStartsNear(text, p, idx?.tokenInner ?? true))
                 break;
             j = p;
             continue;
@@ -935,6 +973,22 @@ function isTokenCountLabel(text, at, label) {
     const lastSep = Math.max(head.lastIndexOf('_'), head.lastIndexOf('-'));
     return TOKEN_COUNT_HEAD_WORDS.has(head.slice(lastSep + 1));
 }
+function isParserDiagnosticToken(text, at, label) {
+    if (label.toLowerCase() !== 'token' || at < 1)
+        return false;
+    if (text.charAt(at - 1) !== ' ')
+        return false;
+    const head = 'unexpected';
+    const start = at - 1 - head.length;
+    if (start < 0 || text.slice(start, at - 1).toLowerCase() !== head)
+        return false;
+    if (start === 0)
+        return true;
+    const before = text.charAt(start - 1);
+    if (!/[A-Za-z0-9_]/.test(before))
+        return true;
+    return start >= 2 && text.charAt(start - 2) === '\\' && /[A-Za-z"']/.test(before);
+}
 const BACKTICKED_CREDENTIAL_NAME = /^\x60[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\x60[.,;:!?)]*$/;
 const CREDENTIAL_NAME_SEGMENTS = new Set([
     'KEY', 'KEYS', 'TOKEN', 'TOKENS', 'SECRET', 'SECRETS', 'PASSWORD', 'PASSWD', 'PWD', 'CREDENTIAL', 'CREDENTIALS',
@@ -961,29 +1015,41 @@ function labelStartsAt(text, at) {
     re.lastIndex = at;
     return re.test(text);
 }
-function credentialWordStartsAt(text, at) {
+function credentialWordStartsAt(text, at, tokenInner = true) {
     if (at >= text.length)
         return false;
-    if (credentialWordStartsExactlyAt(text, at))
+    if (credentialWordStartsExactlyAt(text, at, tokenInner))
         return true;
     let k = at;
     while (k < text.length && text.charCodeAt(k) === 0x5c)
         k++;
     if (text[k] === '"' || text[k] === "'")
         k++;
-    return k > at && credentialWordStartsExactlyAt(text, k);
+    return k > at && credentialWordStartsExactlyAt(text, k, tokenInner);
 }
-function credentialWordStartsExactlyAt(text, at) {
+function credentialWordStartsExactlyAt(text, at, tokenInner = true) {
     if (at >= text.length)
         return false;
     if (labelStartsAt(text, at))
         return true;
     const re = new RegExp(SECRET_SCHEME_WORD.source, 'iy');
     re.lastIndex = at;
-    return re.test(text);
-}
-function credentialWordStartsNear(text, at) {
-    return credentialWordStartsAt(text, at) || credentialWordStartsAt(text, at + 1);
+    const m = re.exec(text);
+    return m !== null && schemeWordIsInner(m[1] ?? '', tokenInner);
+}
+function credentialWordStartsNear(text, at, tokenInner = true) {
+    return credentialWordStartsAt(text, at, tokenInner) || credentialWordStartsAt(text, at + 1, tokenInner);
+}
+function innerWordMatchAt(text, at, tokenInner) {
+    const lab = new RegExp(SECRET_LABELLED_WORD.source, 'iy');
+    lab.lastIndex = at;
+    const m = lab.exec(text);
+    if (m !== null)
+        return m;
+    const sch = new RegExp(SECRET_SCHEME_WORD.source, 'iy');
+    sch.lastIndex = at;
+    const s = sch.exec(text);
+    return s !== null && schemeWordIsInner(s[1] ?? '', tokenInner) ? s : null;
 }
 function nextPairBeyondFragmentAt(text, at) {
     for (const p of [at, at + 1]) {
@@ -1195,13 +1261,15 @@ function addressExtentEnd(text, from) {
     }
     return end;
 }
-function trailingLabelStart(text, from, end) {
+function trailingLabelStart(text, from, end, tokenInner = true) {
     const window = text.slice(from, Math.min(text.length, end + 12));
     const segLen = end - from;
     let best = -1;
     for (const src of [SECRET_SCHEME_WORD, SECRET_LABELLED_WORD]) {
         const re = new RegExp(src.source, src.flags);
         for (let hit = re.exec(window); hit !== null && hit.index < segLen; hit = re.exec(window)) {
+            if (src === SECRET_SCHEME_WORD && !schemeWordIsInner(hit[1] ?? '', tokenInner))
+                continue;
             if (hit.index + hit[0].length >= segLen && (best === -1 || hit.index < best))
                 best = hit.index;
         }
@@ -1257,14 +1325,8 @@ function isTokenCountAt(text, at) {
     return m !== null && isTokenCountLabel(text, at, m[1] ?? '');
 }
 function innerWordHasValue(text, at, idx) {
-    for (const src of [SECRET_LABELLED_WORD, SECRET_SCHEME_WORD]) {
-        const re = new RegExp(src.source, 'iy');
-        re.lastIndex = at;
-        const m = re.exec(text);
-        if (m !== null)
-            return scanSecretValue(text, at + m[0].length, idx) !== null;
-    }
-    return false;
+    const m = innerWordMatchAt(text, at, idx.tokenInner);
+    return m !== null && scanSecretValue(text, at + m[0].length, idx) !== null;
 }
 function quoteSwallowedBefore(S, at) {
     let k = at - 1;
@@ -1411,11 +1473,13 @@ function quotedAddressEnd(S, from, to) {
     }
     return to;
 }
-function labelCandidates(S, re, regions, out) {
+function labelCandidates(S, pass, regions, out) {
     const text = S.text;
     const unitAt = (k) => S.unitAt(k);
-    const schemePass = re === SECRET_SCHEME_WORD;
-    const idx = new InnerWordIndex(text);
+    const re = pass === 'label' ? SECRET_LABELLED_WORD : SECRET_SCHEME_WORD;
+    const schemePass = pass !== 'label';
+    const tokenPass = pass === 'token';
+    const idx = new InnerWordIndex(text, tokenPass);
     const extensionCache = new Map();
     let stops;
     const push = (start, end, kindText, te = -1, cls) => {
@@ -1482,7 +1546,7 @@ function labelCandidates(S, re, regions, out) {
                     cut--;
                 if (cut > p) {
                     const rest = withoutSeparators(text.slice(p, cut));
-                    if (rest.trim() !== '' && !valueIsWholeMarker(S, p, cut) && !isDiagnosticValue(rest))
+                    if (rest.trim() !== '' && !valueIsWholeMarker(S, p, cut, idx.tokenInner) && !isDiagnosticValue(rest))
                         push(p, cut, REDACTED_SECRET);
                 }
                 if (markerHit && marker !== null) {
@@ -1492,14 +1556,7 @@ function labelCandidates(S, re, regions, out) {
             }
             if (!hasInner || inner === null)
                 return;
-            const lab = new RegExp(SECRET_LABELLED_WORD.source, 'iy');
-            lab.lastIndex = inner.start;
-            let m = lab.exec(text);
-            if (m === null) {
-                const sch = new RegExp(SECRET_SCHEME_WORD.source, 'iy');
-                sch.lastIndex = inner.start;
-                m = sch.exec(text);
-            }
+            const m = innerWordMatchAt(text, inner.start, idx.tokenInner);
             if (m === null)
                 return;
             const after = inner.start + m[0].length;
@@ -1533,14 +1590,7 @@ function labelCandidates(S, re, regions, out) {
             const close = text.indexOf(q, from);
             outerEnd = close === -1 ? text.length : close;
         }
-        const lab = new RegExp(SECRET_LABELLED_WORD.source, 'iy');
-        lab.lastIndex = at;
-        let m = lab.exec(text);
-        if (m === null) {
-            const sch = new RegExp(SECRET_SCHEME_WORD.source, 'iy');
-            sch.lastIndex = at;
-            m = sch.exec(text);
-        }
+        const m = innerWordMatchAt(text, at, idx.tokenInner);
         if (m === null)
             return;
         const inner = { start: at };
@@ -1583,10 +1633,16 @@ function labelCandidates(S, re, regions, out) {
     re.lastIndex = 0;
     for (let hit = re.exec(text); hit !== null; hit = re.exec(text)) {
         const label = hit[1] ?? '';
+        if (schemePass && (label.toLowerCase() === 'token') !== tokenPass)
+            continue;
         if (isTokenCountLabel(text, hit.index, label))
             continue;
+        if (schemePass && isParserDiagnosticToken(text, hit.index, label))
+            continue;
+        if (schemePass && labelStartsAt(text, hit.index))
+            continue;
         const from = hit.index + hit[0].length;
-        if (credentialWordStartsAt(text, from)) {
+        if (credentialWordStartsAt(text, from, idx.tokenInner)) {
             pushInnerRemainder(from);
             re.lastIndex = from;
             continue;
@@ -1640,7 +1696,7 @@ function labelCandidates(S, re, regions, out) {
                 continue;
             }
         }
-        if (valueIsWholeMarker(S, v.start, v.end)) {
+        if (valueIsWholeMarker(S, v.start, v.end, idx.tokenInner)) {
             re.lastIndex = quoted ? from : v.end;
             continue;
         }
@@ -1672,7 +1728,7 @@ function labelCandidates(S, re, regions, out) {
                 v.end = a;
         }
         if (!quoted) {
-            const trailing = trailingLabelStart(text, v.start, v.end);
+            const trailing = trailingLabelStart(text, v.start, v.end, idx.tokenInner);
             if (trailing > 0 && innerWordHasValue(text, v.start + trailing, idx)) {
                 let e = v.start + trailing;
                 while (e > v.start && (isCutDelimiter(text.charAt(e - 1)) || text[e - 1] === VIEW_SEPARATOR))
@@ -1691,7 +1747,7 @@ function labelCandidates(S, re, regions, out) {
             re.lastIndex = quoted ? from : v.end;
             continue;
         }
-        if (schemePass && !quoted && SCHEME_FOLLOWER_WORDS.has(value.replace(/[.,;:!?)]+$/, '').toLowerCase())) {
+        if (schemePass && !quoted && schemeFollowerReleased(label, value, text.charCodeAt(hit.index - 1) === 0x2f)) {
             re.lastIndex = v.end;
             continue;
         }
@@ -1730,7 +1786,7 @@ function labelCandidates(S, re, regions, out) {
             if (isAddressShaped(value, rawValue) || rawAddress) {
                 const extentFrom = forbiddenAddress ? forbiddenAt : v.start;
                 let end = quoted ? quotedAddressEnd(S, extentFrom, v.end) : addressExtentEnd(text, extentFrom);
-                const trailing = trailingLabelStart(text, v.start, end);
+                const trailing = trailingLabelStart(text, v.start, end, idx.tokenInner);
                 if (trailing !== -1)
                     end = v.start + trailing;
                 if (gluedToSingleUnit(v.start, hit.index, unitAt) || userinfoHostHidden(text, v.start, unitAt)) {
@@ -2357,7 +2413,7 @@ function joinedSurface(raw, V, spacesKept = false, M = null) {
 function screenSurfaces(text, o) {
     const face = o.face;
     if (face === null)
-        return { surfaces: [], rawSoft: null, rawPlain: null };
+        return { surfaces: [], rawSoft: null, rawPlain: null, contents: [] };
     const unsafe = face.unsafe === null ? null : new RegExp(face.unsafe.source, 'u');
     const keepBlanks = face.keepBlanks === true;
     const chars = [];
@@ -2431,7 +2487,7 @@ function screenSurfaces(text, o) {
         i += w;
     }
     if (!changed)
-        return { surfaces: [], rawSoft: null, rawPlain: null };
+        return { surfaces: [], rawSoft: null, rawPlain: null, contents: [] };
     const screen = chars.join('');
     const M = { ps: Int32Array.from(ps), pe: Int32Array.from(pe), pdot: Uint8Array.from(pdot), rawDot };
     const V = buildScanView(screen, o);
@@ -2451,7 +2507,8 @@ function screenSurfaces(text, o) {
     const joinedSpaced = o.escapeSpaces !== null ? joinedSurface(text, V, true, M) : null;
     if (joinedSpaced !== null)
         out.push(joinedSpaced);
-    return { surfaces: out, rawSoft, rawPlain };
+    const contents = V.contents.map(([a, b]) => ({ sub: screen.slice(a, b), rawAt: (k) => M.ps[a + k] ?? 0, rawEndAt: (k) => M.pe[a + k] ?? 0 }));
+    return { surfaces: out, rawSoft, rawPlain, contents };
 }
 function finalIsStructural(text, at) {
     if (text.charCodeAt(at) !== 0x5c)
@@ -2735,8 +2792,9 @@ function collectCandidates(text, o, nested) {
         if (o.words) {
             editsToCandidates(pemEdits(S, (blk) => { if (S === regionSurface)
                 pemBlocksSeen.push(pemBlockToRaw(S, blk)); }), 'pem', cands);
-            labelCandidates(S, SECRET_SCHEME_WORD, regions, cands);
-            labelCandidates(S, SECRET_LABELLED_WORD, regions, cands);
+            labelCandidates(S, 'scheme', regions, cands);
+            labelCandidates(S, 'token', regions, cands);
+            labelCandidates(S, 'label', regions, cands);
             editsToCandidates(authParamEdits(S.text), 'param', cands);
             editsToCandidates(proseLiteralEdits(S.text), 'prose', cands);
         }
@@ -2754,6 +2812,15 @@ function collectCandidates(text, o, nested) {
                 raw.push({ start: a + iv.start, end: a + iv.end, kind: iv.kind, cls: 'nested', tokenEnd: a + iv.end, pretrimmed: true });
             }
         }
+        for (const c of screen.contents) {
+            const inner = collectCandidates(c.sub, o, true);
+            for (const iv of resolveCandidates(c.sub, inner.cands, inner.rawUnit, inner.rawDot, o.words ? pemRegions(inner.pemBlocksSeen) : [], inner.rawSoft, inner.rawPlain)) {
+                const start = c.rawAt(iv.start);
+                const end = c.rawEndAt(iv.end - 1);
+                if (end > start)
+                    raw.push({ start, end, kind: iv.kind, cls: 'nested', tokenEnd: end, pretrimmed: true });
+            }
+        }
     }
     return { cands: raw, rawUnit: V.rawUnit, rawDot: screen.surfaces[0]?.rawDot ?? null, rawSoft: screen.rawSoft, rawPlain: screen.rawPlain, pemBlocksSeen };
 }

package/dist/engineNoticeCodes.d.ts

@@ -1,6 +1,6 @@
+import { CORE_TOOL_TURN_INCOMPLETE_CAUSES, CORE_USER_STEER_UNDRAINED_CAUSES } from './generated/engineNoticeTables.js';
 export type NoticeAudience = 'user' | 'operator';
 export declare const ENGINE_NOTICE_CODES: readonly string[];
-export declare const SERVER_NOTICE_AUDIENCE: Readonly<Record<string, NoticeAudience>>;
 export declare function engineNoticeInCatalog(code: unknown): boolean;
 export declare const ENGINE_NOTICE_AUDIENCE: Readonly<Record<string, NoticeAudience>>;
 export declare function noticeAudienceOf(code: unknown): NoticeAudience;
@@ -155,6 +155,26 @@ export interface ModelUnreachableFactsView {
     sessionId: string;
 }
 export declare function readModelUnreachable(notice: unknown): ModelUnreachableFactsView | undefined;
+export type ToolTurnIncompleteCause = (typeof CORE_TOOL_TURN_INCOMPLETE_CAUSES)[number];
+export interface ToolTurnIncompleteFactsView {
+    cause: string;
+    count: number;
+    toolCallIds?: readonly string[];
+    sessionId: string;
+    runId: string;
+}
+export declare function readToolTurnIncomplete(notice: unknown): ToolTurnIncompleteFactsView | undefined;
+export type UserSteerUndrainedCause = (typeof CORE_USER_STEER_UNDRAINED_CAUSES)[number];
+export interface UserInputUndrainedFactsView {
+    kind: 'steer' | 'followUp';
+    count: number;
+    cause?: string;
+    taskId?: string;
+    sessionId?: string;
+    runId?: string;
+}
+export declare function readUserInputUndrained(notice: unknown): UserInputUndrainedFactsView | undefined;
+export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause'>): string | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -173,6 +193,9 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'resume.legacy_mode_seed_migrated': typeof readLegacyModeSeedMigrated;
     readonly 'context.tool_turn_repaired': typeof readToolTurnRepaired;
     readonly 'server.model_unreachable': typeof readModelUnreachable;
+    readonly 'task.tool_turn_incomplete': typeof readToolTurnIncomplete;
+    readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
+    readonly 'task.user_followup_undrained': typeof readUserInputUndrained;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;