@sema-agent/client-core 0.111.0 → 0.112.0

package/dist/localConfig/skills.js

@@ -0,0 +1,397 @@
+import { SETTINGS_IS_RESERVED_MEMBER_NAME } from '../generated/settingsSchemaFns.js';
+import { readOwnDataValue, appendOwnElement } from '../ownKey.js';
+import { SKILL_OVERRIDE_STATES, effectiveOfShaped, lockOfShaped, lowerTierOf, ownValueIn, secondaryNamesOf, bareNameOf, shapeSkillLayers, shapeSkillSubject, stateAt, withLayerDoc, } from '../skillOverrideChain.js';
+import { settingsWritePlan } from './settingsWrite.js';
+import { isDotSegment } from '../sessionIdSegment.js';
+import { slotReadOf } from '../wireFailureShape.js';
+import { SKILL_ROOT_LAYERS, SKILL_ROOT_KINDS, SKILL_OVERRIDE_SCOPES } from './skillsWords.js';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const LIST_BUDGET = 4096;
+function listOf(v) {
+    if (!Array.isArray(v))
+        return [];
+    const n = own(v, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0 || n > LIST_BUDGET)
+        return [];
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(own(v, String(i)));
+    return out;
+}
+const TRUST_LAYERS = ['project', 'additional'];
+function pathFormOf(raw) {
+    if (typeof raw !== 'string' || raw === '' || raw.length > 4096 || raw.includes('\u0000'))
+        return undefined;
+    const sep = raw.includes('\\') && !raw.includes('/') ? '\\' : '/';
+    let floor;
+    if (raw.startsWith('/'))
+        floor = '/';
+    else if (/^[A-Za-z]:[\\/]/.test(raw))
+        floor = raw.slice(0, 3);
+    else if (/^\\\\[^\\/]+[\\/][^\\/]+/.test(raw))
+        floor = raw.match(/^\\\\[^\\/]+[\\/][^\\/]+/)[0];
+    else
+        return undefined;
+    let path = raw;
+    while (path.length > floor.length && (path.endsWith('/') || path.endsWith('\\')))
+        path = path.slice(0, -1);
+    const rest = path.slice(floor.length);
+    if (rest !== '' && rest.split(/[\\/]/).some((seg) => seg === '' || isDotSegment(seg)))
+        return undefined;
+    return { sep, path, floor };
+}
+const joinPath = (f, ...segs) => (f.path === f.floor && /[\\/]$/.test(f.floor) ? f.path + segs.join(f.sep) : [f.path, ...segs].join(f.sep));
+function parentOf(f) {
+    if (f.path.length <= f.floor.length)
+        return undefined;
+    const i = Math.max(f.path.lastIndexOf('/'), f.path.lastIndexOf('\\'));
+    if (i < f.floor.length - 1)
+        return undefined;
+    const up = i < f.floor.length ? f.floor : f.path.slice(0, i);
+    return { sep: f.sep, path: up, floor: f.floor };
+}
+export function skillRootsOf(cwd, hostFacts) {
+    try {
+        const here = pathFormOf(cwd);
+        const home = pathFormOf(own(hostFacts, 'configHome'));
+        if (here === undefined || home === undefined)
+            return undefined;
+        const levels = [here];
+        const gitRaw = own(hostFacts, 'gitRoot');
+        const git = gitRaw === null || gitRaw === undefined ? undefined : pathFormOf(gitRaw);
+        if (git !== undefined) {
+            const chain = [];
+            let at = here;
+            while (at !== undefined) {
+                chain.push(at);
+                if (at.path === git.path)
+                    break;
+                at = parentOf(at);
+            }
+            if (at !== undefined && at.path === git.path)
+                levels.splice(0, levels.length, ...chain);
+        }
+        const managed = pathFormOf(own(hostFacts, 'managedDir'));
+        const extra = listOf(own(hostFacts, 'additionalDirectories')).map(pathFormOf).filter((f) => f !== undefined);
+        const plugins = [];
+        for (const p of listOf(own(hostFacts, 'plugins'))) {
+            const name = own(p, 'name');
+            const root = pathFormOf(own(p, 'root'));
+            if (typeof name === 'string' && name !== '' && root !== undefined)
+                plugins.push({ name, root });
+        }
+        const column = (kind) => {
+            const out = [];
+            const add = (layer, base, dir, plugin) => {
+                if (out.some((r) => r.dir === dir))
+                    return;
+                appendOwnElement(out, Object.freeze({ layer, kind, dir, base: base.path, ...(plugin === undefined ? {} : { plugin }) }));
+            };
+            if (managed !== undefined)
+                add('managed', managed, joinPath(managed, kind));
+            add('user', home, joinPath(home, kind));
+            for (const lv of levels)
+                add('project', lv, joinPath(lv, '.sema', kind));
+            for (const d of extra)
+                add('additional', d, joinPath(d, '.sema', kind));
+            for (const p of plugins)
+                add('plugin', p.root, joinPath(p.root, kind), p.name);
+            return Object.freeze(out);
+        };
+        return Object.freeze({ skills: column('skills'), commands: column('commands'), agents: column('agents') });
+    }
+    catch {
+        return undefined;
+    }
+}
+const LAYER_RANK = { managed: 0, user: 1, project: 2, additional: 3, plugin: 4, synced: 5, mcp: 6, builtin: 7 };
+function rootOf(v) {
+    if (!isRecord(v))
+        return undefined;
+    const layer = SKILL_ROOT_LAYERS.find((w) => w === own(v, 'layer'));
+    const kind = SKILL_ROOT_KINDS.find((w) => w === own(v, 'kind'));
+    const dir = own(v, 'dir');
+    const base = own(v, 'base');
+    if (layer === undefined || kind === undefined || typeof dir !== 'string' || dir === '' || typeof base !== 'string')
+        return undefined;
+    return { layer, kind, dir, base };
+}
+function rootTrust(trust, root) {
+    if (!TRUST_LAYERS.includes(root.layer))
+        return 'ok';
+    if (!isRecord(trust) || own(trust, 'state') !== 'judged')
+        return 'unconfirmed';
+    for (const r of listOf(own(trust, 'roots'))) {
+        if (own(r, 'dir') !== root.dir)
+            continue;
+        const t = own(r, 'trusted');
+        if (t === true)
+            return 'ok';
+        if (t !== false)
+            return 'unconfirmed';
+        const why = own(own(r, 'why'), 'kind');
+        return why === 'not_trusted' || why === 'ineligible' ? 'untrusted' : 'unconfirmed';
+    }
+    return 'unconfirmed';
+}
+const truthy = (v) => v === true || v === 'true';
+export function skillsViewOf(listings, layers, trust) {
+    const untrusted = new Set();
+    const unconfirmed = new Set();
+    try {
+        const L = shapeSkillLayers(layers);
+        const rows = [];
+        const raw = listOf(listings);
+        for (let i = 0; i < raw.length; i++) {
+            const e = raw[i];
+            const fm = own(e, 'frontmatter');
+            const dmi = truthy(own(fm, 'disable-model-invocation'));
+            const s = shapeSkillSubject(isRecord(e) ? { ...snapshotSubject(e), disableModelInvocation: dmi } : undefined);
+            if (s === undefined)
+                continue;
+            const rootRaw = own(e, 'root');
+            const root = rootRaw === undefined ? undefined : rootOf(rootRaw);
+            if (rootRaw !== undefined && root === undefined)
+                continue;
+            const layer = root !== undefined ? root.layer : s.origin === 'mcp' ? 'mcp' : s.origin === 'synced' ? 'synced' : s.origin === 'plugin' ? 'plugin' : 'builtin';
+            const trustWord = root === undefined ? 'ok' : rootTrust(trust, root);
+            if (root !== undefined && trustWord === 'untrusted')
+                untrusted.add(root.dir);
+            if (root !== undefined && trustWord === 'unconfirmed')
+                unconfirmed.add(root.dir);
+            const d = own(fm, 'description');
+            rows.push({ s, layer, order: i, trustWord, description: typeof d === 'string' && d.trim() !== '' ? d.trim() : undefined });
+        }
+        const winner = new Map();
+        for (const r of [...rows].sort((a, b) => { const d = LAYER_RANK[a.layer] - LAYER_RANK[b.layer]; return d !== 0 ? d : a.order - b.order; })) {
+            if (r.trustWord !== 'ok')
+                continue;
+            if (!winner.has(r.s.name))
+                winner.set(r.s.name, r);
+        }
+        const entries = [];
+        for (const r of rows) {
+            const effective = effectiveOfShaped(L, r.s);
+            const lock = lockOfShaped(L, r.s);
+            const editable = lock === undefined ? Object.freeze({ ok: true }) : Object.freeze({ ok: false, lockedBy: lock.source });
+            const base = { name: r.s.name, layer: r.layer, effective, editable };
+            const excluded = (reason) => {
+                const e = { ...base, status: 'excluded', reason };
+                return Object.freeze(e);
+            };
+            const applied = (extra) => {
+                const e = { ...base, status: 'applied', ...extra };
+                return Object.freeze(e);
+            };
+            if (r.trustWord !== 'ok')
+                appendOwnElement(entries, excluded(r.trustWord));
+            else if (winner.get(r.s.name) !== r)
+                appendOwnElement(entries, excluded('shadowed'));
+            else if (r.s.disableModelInvocation)
+                appendOwnElement(entries, excluded('model_invocation_off'));
+            else if (effective.value === 'off' || effective.value === 'user-invocable-only')
+                appendOwnElement(entries, excluded('overridden'));
+            else if (effective.value === 'name-only')
+                appendOwnElement(entries, applied({ nameOnly: true }));
+            else
+                appendOwnElement(entries, applied(r.description === undefined ? {} : { description: r.description }));
+        }
+        return Object.freeze({ entries: Object.freeze(entries), withheldRoots: Object.freeze({ untrusted: untrusted.size, unconfirmed: unconfirmed.size }) });
+    }
+    catch {
+        return Object.freeze({ entries: Object.freeze([]), withheldRoots: Object.freeze({ untrusted: untrusted.size, unconfirmed: unconfirmed.size }) });
+    }
+}
+function snapshotSubject(e) {
+    const out = {};
+    for (const k of ['name', 'origin', 'unqualifiedName', 'bareNameReserved', 'aliases', 'mcpLabels', 'reservedLabels', 'syncedNames', 'followsSyncedSkillState', 'hiddenBehindPlugin']) {
+        const v = own(e, k);
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+export function skillsSetEditOf(entry, state, scope) {
+    return Object.freeze({ kind: 'set_override', name: entry.name, state, scope });
+}
+export function skillsClearEditOf(entry) {
+    const by = own(own(entry, 'effective'), 'decidedBy');
+    const name = own(entry, 'name');
+    if (typeof name !== 'string' || name === '')
+        return undefined;
+    const editable = slotReadOf(entry, 'editable');
+    if (editable.presence === 'unreadable')
+        return undefined;
+    if (editable.presence === 'present' && editable.value !== undefined && own(editable.value, 'ok') !== true)
+        return undefined;
+    if (by === 'localSettings')
+        return Object.freeze({ kind: 'clear_override', name, scope: 'local' });
+    if (by === 'userSettings')
+        return Object.freeze({ kind: 'clear_override', name, scope: 'user' });
+    return undefined;
+}
+const LOCK_REFUSAL = {
+    policy: 'skill_locked_by_higher_layer',
+    flag: 'skill_locked_by_higher_layer',
+    plugin: 'skill_managed_by_plugin',
+    'skill-author': 'skill_locked_by_author',
+    'reserved-name': 'skill_name_unstorable',
+};
+const DOC_DECIDERS = ['policySettings', 'localSettings', 'projectSettings', 'userSettings'];
+function docOf(r) {
+    if (r === undefined)
+        return undefined;
+    if (r.status === 'loaded')
+        return r.doc;
+    if (r.status === 'absent' || r.status === 'outside_fence')
+        return null;
+    return undefined;
+}
+function overrideDiff(L, target, r, desiredState, subjects) {
+    const m = new Map();
+    const ov = L.docs[target];
+    const lower = (s) => lowerTierOf(L, s, target, false);
+    const desired = (s) => s.name === r.name ? desiredState : (lockOfShaped(L, s)?.value ?? ownValueIn(ov, s) ?? lower(s) ?? 'on');
+    const u = desiredState;
+    const O = lower(r) ?? 'on';
+    const v = ownValueIn(ov, r) ?? O;
+    if (r.origin === 'mcp') {
+        if (u === v)
+            return m;
+        const k = u === O ? undefined : u;
+        if (k !== stateAt(ov, r.name) || m.has(r.name))
+            m.set(r.name, k);
+        for (const c of secondaryNamesOf(r)) {
+            if (stateAt(ov, c) === undefined)
+                continue;
+            for (const s of subjects) {
+                if (s.name === r.name || s.origin !== 'mcp' || !secondaryNamesOf(s).includes(c) || m.has(s.name))
+                    continue;
+                const h = ownValueIn(ov, s);
+                if ((lockOfShaped(L, s) !== undefined || desired(s) === (h ?? lower(s) ?? 'on')) && h !== undefined)
+                    m.set(s.name, h);
+            }
+            m.set(c, undefined);
+        }
+        return m;
+    }
+    const bare = r.origin === 'synced' ? bareNameOf(r) : undefined;
+    if (bare !== undefined && stateAt(ov, bare) !== undefined && u !== v) {
+        const p = lowerTierOf(L, r, target, true) ?? 'on';
+        const k = u === p ? undefined : u;
+        if (k !== stateAt(ov, r.name))
+            m.set(r.name, k);
+        m.set(bare, undefined);
+        return m;
+    }
+    if (r.origin === 'synced' && u === v)
+        return m;
+    const d = u === O ? undefined : u;
+    if (d !== stateAt(ov, r.name))
+        m.set(r.name, d);
+    return m;
+}
+function clearDiff(L, target, r, subjects) {
+    const m = new Map();
+    const ov = L.docs[target];
+    if (stateAt(ov, r.name) !== undefined)
+        m.set(r.name, undefined);
+    for (const c of secondaryNamesOf(r)) {
+        if (stateAt(ov, c) === undefined)
+            continue;
+        if (r.origin === 'mcp') {
+            for (const s of subjects) {
+                if (s.name === r.name || s.origin !== 'mcp' || !secondaryNamesOf(s).includes(c) || m.has(s.name))
+                    continue;
+                const h = ownValueIn(ov, s);
+                if (h !== undefined)
+                    m.set(s.name, h);
+            }
+        }
+        m.set(c, undefined);
+    }
+    return m;
+}
+export function skillOverrideWritePlan(edit, context) {
+    try {
+        if (!isRecord(edit))
+            return Object.freeze({ ok: false, reason: 'invalid_request' });
+        const kind = own(edit, 'kind');
+        const name = own(edit, 'name');
+        const scope = SKILL_OVERRIDE_SCOPES.find((w) => w === own(edit, 'scope'));
+        const stateRaw = own(edit, 'state');
+        const state = SKILL_OVERRIDE_STATES.find((w) => w === stateRaw);
+        if ((kind !== 'set_override' && kind !== 'clear_override') || typeof name !== 'string' || name === '' || name.length > 512 || scope === undefined)
+            return Object.freeze({ ok: false, reason: 'invalid_request' });
+        if (kind === 'set_override' ? state === undefined : stateRaw !== undefined)
+            return Object.freeze({ ok: false, reason: 'invalid_request' });
+        if (SETTINGS_IS_RESERVED_MEMBER_NAME(name))
+            return Object.freeze({ ok: false, reason: 'skill_name_unstorable' });
+        const target = scope === 'local' ? 'localSettings' : 'userSettings';
+        const snapshot = ['policySettings', 'projectSettings', 'localSettings', 'userSettings'].filter((d) => d !== target);
+        const subjects = listOf(own(context, 'subjects'))
+            .map((v) => shapeSkillSubject(v))
+            .filter((s) => s !== undefined);
+        const flag = own(context, 'flagSettings');
+        const session = own(context, 'session');
+        const disabledSources = own(context, 'disabledSources');
+        const envOff = own(context, 'bundledSkillsDisabledByEnv') === true;
+        const plan = ({ fresh }) => {
+            const docs = {};
+            for (const d of [target, ...snapshot]) {
+                const doc = docOf(fresh[d]);
+                if (doc === undefined)
+                    return { kind: 'refuse', reason: 'scope_unreadable' };
+                docs[d] = doc;
+            }
+            const L = shapeSkillLayers({ ...docs, flagSettings: flag, session, disabledSources, bundledSkillsDisabledByEnv: envOff });
+            const r = subjects.find((s) => s.name === name);
+            if (r === undefined)
+                return { kind: 'refuse', reason: 'not_found' };
+            const lock = lockOfShaped(L, r);
+            if (lock !== undefined)
+                return { kind: 'refuse', reason: LOCK_REFUSAL[lock.source] };
+            const diff = kind === 'set_override' ? overrideDiff(L, target, r, state, subjects) : clearDiff(L, target, r, subjects);
+            const current = docs[target] ?? null;
+            let next = null;
+            if (diff.size > 0) {
+                const edits = [...diff].map(([member, value]) => value === undefined ? { intent: 'skillOverride', member, op: 'delete' } : { intent: 'skillOverride', member, op: 'set', value });
+                const w = settingsWritePlan({ doc: target, current, trust: 'unreadable', edits });
+                if (!w.ok)
+                    return { kind: 'refuse', reason: w.reason, ...(w.detail === undefined ? {} : { detail: w.detail }) };
+                if (w.changed)
+                    next = w.next;
+            }
+            const after = effectiveOfShaped(next === null ? L : withLayerDoc(L, target, next), r);
+            const layer = DOC_DECIDERS.find((d) => d === after.decidedBy);
+            const wanted = kind === 'set_override' ? state : undefined;
+            const disclose = layer === undefined ? [] : [{ kind: wanted === undefined || after.value === wanted ? 'decided_by' : 'shadowed_by', layer }];
+            return next === null ? { kind: 'unchanged', disclose } : { kind: 'write', next, disclose };
+        };
+        const intent = Object.freeze({
+            appliesOn: 'next_turn',
+            steps: Object.freeze([Object.freeze({ doc: target, role: 'effect', snapshot: Object.freeze([...snapshot]), plan })]),
+        });
+        return Object.freeze({ ok: true, intent });
+    }
+    catch {
+        return Object.freeze({ ok: false, reason: 'invalid_request' });
+    }
+}
+const PENDING = Object.freeze({ kind: 'pending' });
+export function skillCreatePlan(_intent) {
+    return PENDING;
+}
+export function skillRemovePlan(_intent) {
+    return PENDING;
+}

package/dist/localConfig/skillsWords.d.ts

@@ -0,0 +1,10 @@
+export declare const SKILL_ROOT_LAYERS: readonly ["managed", "user", "project", "additional", "plugin"];
+export type SkillRootLayer = (typeof SKILL_ROOT_LAYERS)[number];
+export declare const SKILL_ROOT_KINDS: readonly ["skills", "commands", "agents"];
+export type SkillRootKind = (typeof SKILL_ROOT_KINDS)[number];
+export declare const SKILLS_VIEW_EXCLUDED_REASONS: readonly ["overridden", "model_invocation_off", "untrusted", "unconfirmed", "shadowed"];
+export type SkillsViewExcludedReason = (typeof SKILLS_VIEW_EXCLUDED_REASONS)[number];
+export declare const SKILLS_VIEW_LAYERS: readonly ["managed", "user", "project", "additional", "plugin", "mcp", "builtin", "synced"];
+export type SkillsViewLayer = (typeof SKILLS_VIEW_LAYERS)[number];
+export declare const SKILL_OVERRIDE_SCOPES: readonly ["local", "user"];
+export type SkillOverrideScope = (typeof SKILL_OVERRIDE_SCOPES)[number];

package/dist/localConfig/skillsWords.js

@@ -0,0 +1,5 @@
+export const SKILL_ROOT_LAYERS = Object.freeze(['managed', 'user', 'project', 'additional', 'plugin']);
+export const SKILL_ROOT_KINDS = Object.freeze(['skills', 'commands', 'agents']);
+export const SKILLS_VIEW_EXCLUDED_REASONS = Object.freeze(['overridden', 'model_invocation_off', 'untrusted', 'unconfirmed', 'shadowed']);
+export const SKILLS_VIEW_LAYERS = Object.freeze([...SKILL_ROOT_LAYERS, 'mcp', 'builtin', 'synced']);
+export const SKILL_OVERRIDE_SCOPES = Object.freeze(['local', 'user']);

package/dist/mcpProbeWire.js

@@ -1,5 +1,6 @@
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { wireFailureShapeOf } from './wireFailureShape.js';
+import { LIMIT_RATE_EXCEEDED } from './engineErrorCodes.js';
 import { mcpProbeAvailable } from './mcpProbeCapability.js';
 import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
@@ -50,7 +51,7 @@ export function classifyMcpProbeFailure(e) {
             return refusedBy('body_unparseable', message);
         case 'request.payload_too_large':
             return refusedBy('payload_too_large', message);
-        case 'limit.rate_exceeded':
+        case LIMIT_RATE_EXCEEDED:
             return refusedBy('rate_limited', message, retryAfterSec);
         case 'auth.unauthorized':
             return refusedBy('unauthorized', message);

package/dist/mcpWireCaps.js

@@ -448,6 +448,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.148.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.149.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/memoryVerbsWire.js

@@ -1,4 +1,5 @@
 import { wireFailureShapeOf } from './wireFailureShape.js';
+import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, MEMORY_CONTROL_PLANE_CORRUPT } from './engineErrorCodes.js';
 import { memoryComplianceVerbsAvailable } from './memoryComplianceCapability.js';
 import { memoryOriginVerbsAvailable } from './memoryOriginCapability.js';
 import { readMemoryEraseReceipt, readMemoryOriginClearanceReceipt } from './memoryEntriesWire.js';
@@ -53,7 +54,7 @@ export function classifyMemoryFailure(e) {
             return refusedBy('unauthorized', message);
         case 'auth.operator_only':
             return refusedBy('operator_only', message);
-        case 'capability.operator_principals_required':
+        case CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED:
             return refusedBy('operators_unconfigured', message);
         case 'auth.service_token_required':
             return refusedBy('service_token_required', message);
@@ -94,7 +95,7 @@ export function classifyMemoryFailure(e) {
         case 'memory.target_outside_store':
         case 'memory.scope_home_not_directory':
             return unknownBy('store_form_refused', message);
-        case 'internal.memory_control_plane_corrupt':
+        case MEMORY_CONTROL_PLANE_CORRUPT:
             return unknownBy('control_plane_corrupt', message);
         default:
             break;

package/dist/model/onboardJudgement.d.ts

@@ -1,7 +1,10 @@
-import type { ModelApiWord } from './providerPresets.js';
-import type { OnboardCatalogIssue, OnboardProbeResult, OnboardProbeVerdict, OnboardRefusal } from '../seatContract.js';
+import { type ModelApiWord } from './providerPresets.js';
+import type { ModelDiscoveryResult, OnboardCatalogIssue, OnboardProbeResult, OnboardProbeVerdict, OnboardRefusal } from '../seatContract.js';
+import type { SettingsDocument } from '../host.js';
 import { type ModelProbeResult } from '../modelCapabilityProbe.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
+export declare function onboardKeyCarriedBy(text: string, key: string | undefined): boolean;
+export declare function onboardRedactKey(text: string, key: string | undefined): string;
 export declare function onboardBaseUrlProblem(url: string, lang?: UiLanguage): string | undefined;
 export interface OnboardProbeTarget {
     readonly baseUrl: string;
@@ -42,6 +45,13 @@ export interface OnboardProbeDeps {
     readonly firstTokenMs?: number | undefined;
 }
 export declare function probeModelEndpoint(target: OnboardProbeTarget, deps?: OnboardProbeDeps): Promise<OnboardProbeResult>;
+export interface OnboardDiscoveryTarget {
+    readonly baseUrl: string;
+    readonly api: ModelApiWord;
+    readonly apiKey?: string | undefined;
+    readonly auth?: 'bearer' | 'x-api-key' | undefined;
+}
+export declare function discoverEndpointModels(target: OnboardDiscoveryTarget, deps?: OnboardProbeDeps): Promise<ModelDiscoveryResult>;
 export type OnboardWriteVerdict = {
     readonly write: true;
     readonly unverified: boolean;
@@ -49,10 +59,11 @@ export type OnboardWriteVerdict = {
     readonly write: false;
     readonly refusal: 'probe_failed' | 'probe_unverified';
 };
-export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict, acceptUnverified?: boolean): OnboardWriteVerdict;
+export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict | undefined, acceptUnverified?: boolean): OnboardWriteVerdict;
 export declare const KEY_SLOT_PREFIX = "SEMA_MODEL_KEY_";
 export declare function keyEnvNameForEntry(entryName: string): string;
 export declare function poolEntryNameOf(modelId: string, channel: string, taken: ReadonlySet<string>): string;
+export declare function onboardEntryCredentialIssue(m: SettingsDocument, env: Readonly<Record<string, string | undefined>>): string | undefined;
 export interface OnboardPlanEntry {
     readonly modelId: string;
     readonly api: ModelApiWord;
@@ -90,5 +101,4 @@ export type OnboardWritePlan = {
     readonly refusal: Extract<OnboardRefusal, 'input' | 'catalog_unreadable' | 'credential_unpaired' | 'engine_is_remote' | 'env_catalog_present'>;
     readonly detail: string;
 };
-export declare function onboardWritePlan(input: OnboardWritePlanInput): OnboardWritePlan;
 export declare function onboardRefusalText(refusal: OnboardRefusal, lang?: UiLanguage): string;