@sema-agent/client-core 0.111.0 → 0.112.1

package/dist/skillOverrideChain.js

@@ -0,0 +1,378 @@
+import { SETTINGS_IS_RESERVED_MEMBER_NAME } from './generated/settingsSchemaFns.js';
+import { readOwnDataValue } from './ownKey.js';
+export const SKILL_OVERRIDE_STATES = Object.freeze(['on', 'name-only', 'user-invocable-only', 'off']);
+export const SKILL_ORIGINS = Object.freeze(['skills', 'synced', 'commands', 'mcp', 'plugin', 'builtin', 'bundled']);
+export const SKILL_OVERRIDE_LAYERS = Object.freeze(['policySettings', 'flagSettings', 'localSettings', 'projectSettings', 'userSettings']);
+export const SKILL_OVERRIDE_DECIDERS = Object.freeze([...SKILL_OVERRIDE_LAYERS, 'session', 'default', 'plugin', 'builtin_clamp', 'hidden_behind_plugin']);
+export const SKILL_OVERRIDE_LOCK_SOURCES = Object.freeze(['policy', 'flag', 'plugin', 'skill-author', 'reserved-name']);
+const MANAGED = ['policySettings', 'flagSettings'];
+const PLAIN = ['localSettings', 'projectSettings', 'userSettings'];
+const MERGED = ['policySettings', 'flagSettings', 'localSettings', 'projectSettings', 'userSettings'];
+const RANK = { on: 0, 'name-only': 1, 'user-invocable-only': 2, off: 3 };
+const LIST_BUDGET = 4096;
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+const isState = (v) => typeof v === 'string' && SKILL_OVERRIDE_STATES.some((w) => w === v);
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function stringsOf(v) {
+    const out = [];
+    if (!Array.isArray(v))
+        return out;
+    let n;
+    try {
+        n = own(v, 'length');
+    }
+    catch {
+        return out;
+    }
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0 || n > LIST_BUDGET)
+        return out;
+    for (let i = 0; i < n; i++) {
+        const s = own(v, String(i));
+        if (typeof s === 'string' && s !== '')
+            out.push(s);
+    }
+    return out;
+}
+export function shapeSkillSubject(v) {
+    if (!isRecord(v))
+        return undefined;
+    const name = own(v, 'name');
+    const originRaw = own(v, 'origin');
+    const origin = SKILL_ORIGINS.find((w) => w === originRaw);
+    if (typeof name !== 'string' || name === '' || origin === undefined)
+        return undefined;
+    const unq = own(v, 'unqualifiedName');
+    const synced = [];
+    const rawSynced = own(v, 'syncedNames');
+    if (Array.isArray(rawSynced)) {
+        const n = own(rawSynced, 'length');
+        if (typeof n === 'number' && Number.isSafeInteger(n) && n >= 0 && n <= LIST_BUDGET) {
+            for (let i = 0; i < n; i++) {
+                const e = own(rawSynced, String(i));
+                const sn = own(e, 'name');
+                const sb = own(e, 'bare');
+                if (typeof sn === 'string' && sn !== '' && typeof sb === 'string' && sb !== '')
+                    synced.push(Object.freeze({ name: sn, bare: sb }));
+            }
+        }
+    }
+    return Object.freeze({
+        name,
+        origin,
+        unqualifiedName: typeof unq === 'string' && unq !== '' ? unq : undefined,
+        bareNameReserved: own(v, 'bareNameReserved') === true,
+        aliases: Object.freeze(stringsOf(own(v, 'aliases'))),
+        mcpLabels: Object.freeze(stringsOf(own(v, 'mcpLabels')).filter((s) => s.includes(':'))),
+        reservedLabels: Object.freeze(stringsOf(own(v, 'reservedLabels'))),
+        syncedNames: Object.freeze(synced),
+        followsSyncedSkillState: own(v, 'followsSyncedSkillState') === true,
+        disableModelInvocation: own(v, 'disableModelInvocation') === true,
+        hiddenBehindPlugin: own(v, 'hiddenBehindPlugin') === true,
+    });
+}
+function overridesOf(doc) {
+    const ov = own(doc, 'skillOverrides');
+    return isRecord(ov) ? ov : undefined;
+}
+export function shapeSkillLayers(v) {
+    const docs = {};
+    for (const l of SKILL_OVERRIDE_LAYERS)
+        docs[l] = overridesOf(own(v, l));
+    const disabled = new Set(stringsOf(own(v, 'disabledSources')));
+    const session = own(v, 'session');
+    const enabled = (layer) => layer === 'policySettings' || layer === 'flagSettings' || !disabled.has(layer);
+    let fromSettings = false;
+    for (const l of MERGED) {
+        if (!enabled(l))
+            continue;
+        const b = own(own(v, l), 'disableBundledSkills');
+        if (typeof b === 'boolean') {
+            fromSettings = b;
+            break;
+        }
+    }
+    return Object.freeze({
+        docs: Object.freeze(docs),
+        session: isRecord(session) ? session : undefined,
+        enabled,
+        bundledDisabled: fromSettings || own(v, 'bundledSkillsDisabledByEnv') === true,
+    });
+}
+function at(ov, key) {
+    if (ov === undefined || key === undefined)
+        return undefined;
+    const w = own(ov, key);
+    return isState(w) ? w : undefined;
+}
+const hitAt = (ov, key, by) => {
+    const w = at(ov, key);
+    return w === undefined ? undefined : { value: w, by };
+};
+function stricter(a, b) {
+    if (a === undefined)
+        return b;
+    return b !== undefined && RANK[b.value] > RANK[a.value] ? b : a;
+}
+function strictestIn(ov, names, by) {
+    let r;
+    for (const n of names) {
+        const w = at(ov, n);
+        if (w !== undefined && (r === undefined || RANK[w] > RANK[r.value]))
+            r = { value: w, by };
+    }
+    return r;
+}
+export function bareNameOf(s) {
+    if (s.unqualifiedName === undefined)
+        return undefined;
+    if (s.origin !== 'synced')
+        return s.unqualifiedName;
+    return s.bareNameReserved ? undefined : s.unqualifiedName;
+}
+const freeLabels = (s) => s.mcpLabels.filter((l) => !s.reservedLabels.includes(l));
+function aliasNamesOf(s) {
+    return [...s.aliases, ...(s.unqualifiedName !== undefined ? [s.unqualifiedName] : []), ...freeLabels(s)];
+}
+export function secondaryNamesOf(s) {
+    const bare = bareNameOf(s);
+    return [...(bare !== undefined ? [bare] : []), ...(s.origin === 'mcp' ? freeLabels(s) : [])];
+}
+function reservedTighten(ov, s, by) {
+    const r = strictestIn(ov, s.reservedLabels, by);
+    return r === undefined || r.value === 'on' ? undefined : r;
+}
+function mergedAt(L, key) {
+    for (const l of MERGED) {
+        if (!L.enabled(l))
+            continue;
+        const h = hitAt(L.docs[l], key, l);
+        if (h !== undefined)
+            return h;
+    }
+    return undefined;
+}
+function viewThenSession(L, names) {
+    for (const n of names) {
+        const h = mergedAt(L, n);
+        if (h !== undefined)
+            return h;
+    }
+    for (const n of names) {
+        const h = hitAt(L.session, n, 'session');
+        if (h !== undefined)
+            return h;
+    }
+    return undefined;
+}
+function managedOnly(L, names) {
+    for (const n of names)
+        for (const l of MANAGED) {
+            const h = hitAt(L.docs[l], n, l);
+            if (h !== undefined)
+                return h;
+        }
+    return undefined;
+}
+function mcpChain(L, s, rest) {
+    const names = [s.name, ...rest];
+    let m;
+    let tight;
+    for (const l of MANAGED) {
+        m = stricter(m, strictestIn(L.docs[l], names, l));
+        tight = stricter(tight, reservedTighten(L.docs[l], s, l));
+    }
+    if (m !== undefined)
+        return stricter(m, tight);
+    for (const l of PLAIN) {
+        if (!L.enabled(l))
+            continue;
+        const b = strictestIn(L.docs[l], names, l);
+        if (b !== undefined)
+            return stricter(b, tight);
+    }
+    return stricter(strictestIn(L.session, names, 'session'), tight);
+}
+function overrideChain(L, s, mode) {
+    const rest = secondaryNamesOf(s);
+    if (s.origin === 'mcp')
+        return mcpChain(L, s, rest);
+    let v = (mode === 'all' ? viewThenSession : managedOnly)(L, [s.name, ...rest]);
+    const aliases = aliasNamesOf(s);
+    if (aliases.length === 0)
+        return v;
+    for (const l of MANAGED) {
+        const ov = L.docs[l];
+        if (at(ov, s.name) !== undefined)
+            break;
+        const w = strictestIn(ov, aliases, l);
+        if (w !== undefined && (v === undefined || RANK[w.value] > RANK[v.value]))
+            v = w;
+        if (rest.some((d) => at(ov, d) !== undefined))
+            break;
+    }
+    return v;
+}
+function managedLock(L, s, mode) {
+    const aliases = aliasNamesOf(s);
+    let found;
+    for (const l of MANAGED) {
+        const ov = L.docs[l];
+        const b = s.origin === 'mcp'
+            ? stricter(strictestIn(ov, [s.name, ...aliases], l), reservedTighten(ov, s, l))?.value
+            : (at(ov, s.name) ?? strictestIn(ov, aliases, l)?.value ?? reservedTighten(ov, s, l)?.value);
+        if (b === undefined)
+            continue;
+        if (s.origin !== 'mcp') {
+            found = { value: b, source: l };
+            break;
+        }
+        if (found === undefined || RANK[b] > RANK[found.value])
+            found = { value: b, source: l };
+    }
+    if (found === undefined)
+        return undefined;
+    const chain = overrideChain(L, s, mode);
+    return chain !== undefined ? { value: chain.value, source: found.source, by: chain.by } : { value: found.value, source: found.source, by: found.source };
+}
+function pluginManaged(L, s) {
+    if (s.origin !== 'plugin')
+        return managedLock(L, s, 'all');
+    let n;
+    for (const sn of s.syncedNames) {
+        const h = Object.freeze({
+            ...EMPTY_SUBJECT,
+            name: sn.name,
+            origin: 'synced',
+            unqualifiedName: sn.bare,
+            bareNameReserved: !s.aliases.includes(sn.bare),
+        });
+        const y = managedLock(L, h, 'administrator');
+        if (y !== undefined && (n === undefined || RANK[y.value] > RANK[n.value]))
+            n = y;
+    }
+    return n;
+}
+const EMPTY_SUBJECT = Object.freeze({
+    name: '',
+    origin: 'skills',
+    unqualifiedName: undefined,
+    bareNameReserved: false,
+    aliases: Object.freeze([]),
+    mcpLabels: Object.freeze([]),
+    reservedLabels: Object.freeze([]),
+    syncedNames: Object.freeze([]),
+    followsSyncedSkillState: false,
+    disableModelInvocation: false,
+    hiddenBehindPlugin: false,
+});
+function pluginFollow(L, s) {
+    let r;
+    for (const sn of s.syncedNames) {
+        const y = viewThenSession(L, s.followsSyncedSkillState || s.aliases.includes(sn.bare) ? [sn.name, sn.bare] : [sn.name]);
+        if (s.followsSyncedSkillState || y?.value === 'user-invocable-only')
+            r = stricter(r, y);
+    }
+    return r;
+}
+const effective = (value, decidedBy) => Object.freeze({ value, decidedBy });
+export function effectiveOfShaped(L, s) {
+    if (s.hiddenBehindPlugin)
+        return effective('off', 'hidden_behind_plugin');
+    if (s.origin === 'plugin') {
+        const m = pluginManaged(L, s);
+        const v = stricter(m === undefined ? undefined : { value: m.value, by: m.by }, pluginFollow(L, s));
+        return v === undefined ? effective('on', 'default') : effective(v.value, v.by);
+    }
+    const r = overrideChain(L, s, 'all');
+    const value = r?.value ?? 'on';
+    if (s.origin === 'builtin' && L.bundledDisabled)
+        return value === 'off' ? effective('off', r?.by ?? 'default') : effective('user-invocable-only', 'builtin_clamp');
+    return effective(value, r?.by ?? 'default');
+}
+const locked = (value, source) => Object.freeze({ value, source });
+export function lockOfShaped(L, s) {
+    const n = pluginManaged(L, s);
+    if (n !== undefined) {
+        const t = s.origin === 'plugin' ? effectiveOfShaped(L, s).value : n.value;
+        return locked(t, t !== n.value ? 'plugin' : n.source === 'policySettings' ? 'policy' : 'flag');
+    }
+    if (SETTINGS_IS_RESERVED_MEMBER_NAME(s.name))
+        return locked(s.disableModelInvocation ? 'user-invocable-only' : 'on', 'reserved-name');
+    if (s.disableModelInvocation)
+        return locked('user-invocable-only', 'skill-author');
+    if (s.origin === 'plugin')
+        return locked(effectiveOfShaped(L, s).value, 'plugin');
+    return undefined;
+}
+export function skillOverrideEffectiveOf(layers, skill) {
+    try {
+        const s = shapeSkillSubject(skill);
+        if (s === undefined)
+            return undefined;
+        return effectiveOfShaped(shapeSkillLayers(layers), s);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function skillOverrideLockOf(layers, skill) {
+    try {
+        const s = shapeSkillSubject(skill);
+        if (s === undefined)
+            return locked('on', 'reserved-name');
+        return lockOfShaped(shapeSkillLayers(layers), s);
+    }
+    catch {
+        return locked('on', 'reserved-name');
+    }
+}
+export function ownValueIn(ov, s) {
+    return s.origin === 'mcp' ? strictestIn(ov, [s.name, ...secondaryNamesOf(s)], 'default')?.value : at(ov, s.name);
+}
+export function stateAt(ov, key) {
+    return at(ov, key);
+}
+export function lowerTierOf(L, s, target, skipTargetBare) {
+    const doc = (l) => ((l === 'localSettings' && target === 'localSettings') || L.enabled(l) ? L.docs[l] : undefined);
+    if (s.origin === 'mcp') {
+        if (target === 'userSettings')
+            return undefined;
+        const names = [s.name, ...secondaryNamesOf(s)];
+        for (const l of ['projectSettings', 'userSettings']) {
+            if (!L.enabled(l))
+                continue;
+            const m = strictestIn(L.docs[l], names, l);
+            if (m !== undefined)
+                return m.value;
+        }
+        return undefined;
+    }
+    const bare = bareNameOf(s);
+    const bareChain = () => {
+        if (bare === undefined)
+            return undefined;
+        for (const l of PLAIN) {
+            if (skipTargetBare && l === target)
+                continue;
+            const w = at(doc(l), bare);
+            if (w !== undefined)
+                return w;
+        }
+        return undefined;
+    };
+    if (target === 'userSettings')
+        return bareChain();
+    return at(doc('projectSettings'), s.name) ?? at(doc('userSettings'), s.name) ?? bareChain();
+}
+export function withLayerDoc(L, layer, doc) {
+    return Object.freeze({ ...L, docs: Object.freeze({ ...L.docs, [layer]: overridesOf(doc) }) });
+}

package/dist/skillsWireCaps.d.ts

@@ -1,5 +1,6 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import { type SkillToolListsReading } from './skillToolListsCapability.js';
+import { type SkillOverrideLayers, type SkillOverrideSubject } from './skillOverrideChain.js';
 export interface SkillCmdLike {
     type?: string;
     name?: string;
@@ -10,6 +11,7 @@ export interface SkillCmdLike {
     skillRoot?: string;
     allowedTools?: readonly string[];
     disallowedTools?: readonly string[];
+    skillOverrideSubject?: SkillOverrideSubject;
 }
 export declare function toCappedSpec(name: string, description: string, whenToUse: string, body: string): SkillSpec | null;
 export type SkillSpecOnWire = SkillSpec & {
@@ -19,6 +21,7 @@ export interface SkillSpecsOptions {
     toolsRunHere?: boolean;
     platform?: 'posix' | 'win32';
     skillToolLists?: SkillToolListsReading;
+    skillOverrides?: SkillOverrideLayers;
 }
 export declare function skillBaseDirOf(skillRoot: string | undefined, platform?: 'posix' | 'win32'): string | undefined;
 export type SkillToolListKey = 'allowedTools' | 'disallowedTools';

package/dist/skillsWireCaps.js

@@ -1,6 +1,7 @@
 import { skillToolListsAvailable } from './skillToolListsCapability.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { appendOwnElement } from './ownKey.js';
+import { skillOverrideEffectiveOf } from './skillOverrideChain.js';
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
     const c = body.trim();
@@ -11,6 +12,13 @@ export function toCappedSpec(name, description, whenToUse, body) {
         .join(' — ');
     return { name: n, description: desc, content: c };
 }
+const ORIGIN_OF_SOURCE = { plugin: 'plugin', builtin: 'builtin', bundled: 'bundled', mcp: 'mcp' };
+function overrideSubjectOf(cmd, name) {
+    if (cmd.skillOverrideSubject !== undefined)
+        return cmd.skillOverrideSubject;
+    const src = typeof cmd.source === 'string' && Object.hasOwn(ORIGIN_OF_SOURCE, cmd.source) ? ORIGIN_OF_SOURCE[cmd.source] : undefined;
+    return { name, origin: src ?? 'skills' };
+}
 export function skillBaseDirOf(skillRoot, platform = 'posix') {
     if (skillRoot === undefined || skillRoot.length === 0 || skillRoot.length > 4096)
         return undefined;
@@ -120,10 +128,17 @@ export function skillCommandsToSpecs(cmds, resolveBody, opts) {
     for (const cmd of cmds) {
         if (cmd.type !== 'prompt' || cmd.disableModelInvocation)
             continue;
+        let nameOnly = false;
+        if (opts?.skillOverrides !== undefined) {
+            const eff = skillOverrideEffectiveOf(opts.skillOverrides, overrideSubjectOf(cmd, (cmd.name ?? '').trim()));
+            if (eff === undefined || eff.value === 'off' || eff.value === 'user-invocable-only')
+                continue;
+            nameOnly = eff.value === 'name-only';
+        }
         const body = resolveBody(cmd);
         if (!body)
             continue;
-        const spec = toCappedSpec(cmd.name ?? '', cmd.description ?? '', cmd.whenToUse ?? '', body);
+        const spec = toCappedSpec(cmd.name ?? '', nameOnly ? '' : (cmd.description ?? ''), nameOnly ? '' : (cmd.whenToUse ?? ''), body);
         if (!spec || seen.has(spec.name))
             continue;
         seen.add(spec.name);

package/dist/turnFailurePresentation.js

@@ -3,7 +3,8 @@ import { classifyTurnWireError, isPreStreamDrainingReject } from './wireErrorTri
 import { isSseIdleError, streamEndedReasonOf } from './sseIdleTriage.js';
 import { runNotFollowedOf } from './runFollow.js';
 import { isCodeClassifiedGateFailure } from './gateFailureCodes.js';
-import { CORRUPT_ROW_ERROR_CODE, CORRUPT_SESSION_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { DRAINING_ERROR_CODE } from './engineErrorCodes.js';
+import { SDK_NON_RETRYABLE_CODES } from './generated/sdkFactTables.js';
 import { admissionWallRefusalContent, admissionWallRefusalFromError, bodyShapeRefusalFromError, bodyShapeRefusalTouchesSettings, fleetLeaseUnavailableContent, fleetLeaseUnavailableFromError, hostPostureRefusalContent, hostPostureRefusalFromError, fieldLimitRefusalContent, fieldLimitRefusalFromError, toolDeclarationRefusalContent, toolDeclarationRefusalFromError, usageWindowExhaustedContent, usageWindowExhaustedFromError, quotaExhaustedContent, quotaExhaustedFromError, userAttachmentRefusalFromError, } from './wireRefusalCopy.js';
 import { THROWN_SLOT_UNREADABLE, readErrorNumber, readThrownSlot, wireFailureTextsOf } from './wireFailureShape.js';
 import { effectiveCodeOf, ownReadingSlot, provablyNotSent, triageReadingOf } from './engineWireFor.js';
@@ -68,14 +69,7 @@ function isIdleWatchdog(err) {
         return false;
     }
 }
-const DETERMINISTIC_SERVER_CODES = new Set([
-    CORRUPT_SESSION_ERROR_CODE,
-    CORRUPT_ROW_ERROR_CODE,
-    SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
-    MEMORY_CONTROL_PLANE_CORRUPT,
-    'approvals.read_corrupt',
-    'workflow.journal_incompatible',
-]);
+const DETERMINISTIC_SERVER_CODES = new Set(SDK_NON_RETRYABLE_CODES);
 const BROWSER_FETCH_FAILURE = /\bfailed to fetch\b|\bnetworkerror\b|\bnetwork error\b|\bload failed\b/i;
 function httpShapeOf(verdict, code) {
     const status = verdict.status;
@@ -90,7 +84,7 @@ function httpShapeOf(verdict, code) {
         return { category: 'rate_limited', offer: false };
     if (code === 'budget.precall' || code === 'budget.exceeded')
         return { category: 'billing', offer: false };
-    if (code === 'draining' || verdict.leaseUnavailable === true || isPreStreamDrainingReject(facts))
+    if (code === DRAINING_ERROR_CODE || verdict.leaseUnavailable === true || isPreStreamDrainingReject(facts))
         return { category: 'server_error', offer: true };
     if (status === 501 || (code !== undefined && code.startsWith('capability.')))
         return { category: 'capability_unavailable', offer: false };