@sema-agent/client-core 0.91.0 → 0.93.0

package/dist/steerPriorityCapability.js

@@ -0,0 +1,80 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectSteerPriorityCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'fleet'))
+        return { kind: 'not_reported' };
+    const fleet = caps.fleet;
+    if (fleet === undefined || fleet === false)
+        return { kind: 'not_reported' };
+    if (fleet === null || typeof fleet !== 'object' || Array.isArray(fleet))
+        return undefined;
+    if (!Object.hasOwn(fleet, 'steerPriority'))
+        return { kind: 'not_reported' };
+    const v = fleet.steerPriority;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'string' || v.length === 0)
+        return undefined;
+    return { kind: 'present', word: v };
+}
+const reader = createEngineCapReader({
+    name: 'fleet.steerPriority',
+    project: projectSteerPriorityCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSteerPriority(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSteerPriority(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function steerPriorityMode(reading) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return 'unknown';
+        if (!Object.hasOwn(reading, 'kind') || reading.kind !== 'present')
+            return 'unknown';
+        if (!Object.hasOwn(reading, 'word'))
+            return 'unknown';
+        const word = reading.word;
+        return word === 'engine' ? 'engine' : word === 'advisory' ? 'advisory' : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const WORD_DETAIL_MAX = 40;
+export function steerPriorityDoctorDetail(reading) {
+    const unobserved = 'steer priority not observed — the engine reports it on /v1/capabilities (fleet.steerPriority); this process has no usable capabilities reading cached for it, so a "now" or "later" steer is not sent';
+    let kind;
+    let word;
+    try {
+        if (reading === null || typeof reading !== 'object')
+            return unobserved;
+        kind = Object.hasOwn(reading, 'kind') ? reading.kind : undefined;
+        word = kind === 'present' && Object.hasOwn(reading, 'word') ? reading.word : undefined;
+    }
+    catch {
+        return unobserved;
+    }
+    if (kind === 'not_reported') {
+        return 'steer priority not reported by this engine — its capabilities reading carries no fleet.steerPriority (the fleet face is not reported, or the face carries no such field; this client cannot tell which), so a "now" or "later" steer is not sent (steers without a priority work as before)';
+    }
+    if (kind !== 'present' || typeof word !== 'string' || word.length === 0)
+        return unobserved;
+    if (word === 'engine')
+        return 'steer priority applied by the engine — "now" interrupts the running turn, "later" waits until the run would have stopped';
+    if (word === 'advisory') {
+        return 'steer priority accepted but not applied on this deployment — a "now" or "later" steer is not sent (steers without a priority work as before)';
+    }
+    return `steer priority reported as "${capForDisplay(word, WORD_DETAIL_MAX)}" — a value this client does not know yet, so whether it is applied is unknown and a "now" or "later" steer is not sent`;
+}
+export function forgetSteerPriorityReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSteerPriorityReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/steerReceipt.d.ts

@@ -0,0 +1,9 @@
+import type { SteerPriority } from '@sema-agent/sdk';
+export interface SteerReceiptReading {
+    readonly delivery: string | null;
+    readonly status: string | null;
+    readonly messageId?: string;
+    readonly priority?: SteerPriority;
+}
+export declare function ownNonEmptyStringOf(body: unknown, key: string): string | undefined;
+export declare function readSteerReceipt(receipt: unknown): SteerReceiptReading;

package/dist/steerReceipt.js

@@ -0,0 +1,25 @@
+export function ownNonEmptyStringOf(body, key) {
+    try {
+        if (typeof body !== 'object' || body === null || !Object.hasOwn(body, key))
+            return undefined;
+        const v = body[key];
+        return typeof v === 'string' && v.length > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function priorityEchoOf(body) {
+    const v = ownNonEmptyStringOf(body, 'priority');
+    return v === 'now' || v === 'next' || v === 'later' ? v : undefined;
+}
+export function readSteerReceipt(receipt) {
+    const messageId = ownNonEmptyStringOf(receipt, 'messageId');
+    const priority = priorityEchoOf(receipt);
+    return Object.freeze({
+        delivery: ownNonEmptyStringOf(receipt, 'delivery') ?? null,
+        status: ownNonEmptyStringOf(receipt, 'status') ?? null,
+        ...(messageId !== undefined ? { messageId } : {}),
+        ...(priority !== undefined ? { priority } : {}),
+    });
+}

package/dist/storePostureCapability.js

@@ -90,7 +90,7 @@ export function storePostureDoctorDetail(reading) {
     const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
     const r = presentView(reading);
     if (r?.kind === 'not_reported') {
-        return 'store posture not reported by this engine — only newer engines advertise it; this does not say whether this deployment persists its state';
+        return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
     }
     if (r?.kind !== 'present')
         return unobserved;
@@ -120,7 +120,7 @@ export function storePostureDoctorDetail(reading) {
         return `${assembled} — ${lost} (degraded: the declared database could not be opened at start-up, so the engine fell back rather than refusing to start)`;
     }
     if (reason === 'local_unwritable') {
-        return `${assembled} — ${lost} (degraded: the default local file store could not be created, for example a read-only or full data directory)`;
+        return `${assembled} — ${lost} (degraded: the default local file store could not be created — a read-only or full data directory is one possible cause, and this client cannot tell which applies)`;
     }
     return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
 }

package/dist/subagent/engineSubagentSteer.js

@@ -4,19 +4,12 @@ import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { errCodes, steeringRefusedBeforeEngine } from '../controlRouter.js';
+import { ownNonEmptyStringOf } from '../steerReceipt.js';
 function usableSteerClient(client) {
     return clientHasVerbs(client, [['runs', 'steerSubagent']]);
 }
 function steerReceiptMessageId(body) {
-    try {
-        if (typeof body !== 'object' || body === null || !Object.hasOwn(body, 'messageId'))
-            return undefined;
-        const v = body.messageId;
-        return typeof v === 'string' && v.length > 0 ? v : undefined;
-    }
-    catch {
-        return undefined;
-    }
+    return ownNonEmptyStringOf(body, 'messageId');
 }
 export async function steerEngineSubagent(target, text, childTaskId, opts) {
     const named = typeof childTaskId === 'string' && childTaskId !== '' ? childTaskId : undefined;

package/dist/supportFloor.d.ts

@@ -8,3 +8,4 @@ export declare const SUPPORT_FLOOR: Readonly<SupportFloor>;
 export declare function supportFloorOf(component: unknown): string | undefined;
 export type EngineVersionTier = 'engine' | 'legacy' | 'unknown';
 export declare function engineVersionTier(version: unknown, floor?: string): EngineVersionTier;
+export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;

package/dist/supportFloor.js

@@ -1,6 +1,6 @@
 export const SUPPORT_FLOOR = Object.freeze({
-    server: '7.104.0',
-    core: '7.33.8',
+    server: '7.106.0',
+    core: '7.35.2',
     sdk: '12.0.1',
 });
 export function supportFloorOf(component) {
@@ -25,12 +25,16 @@ function compareTriple(a, b) {
     }
     return 0;
 }
-export function engineVersionTier(version, floor) {
-    let need = releaseTriple(SUPPORT_FLOOR.server);
+function versionTierAgainst(version, base, floor, caller) {
+    const baseTriple = releaseTriple(base);
+    if (baseTriple === undefined) {
+        throw new TypeError(`${caller}: 门槛只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)—— 收到 typeof=${base === null ? 'null' : typeof base}。错误文本只报形状,不回显值。`);
+    }
+    let need = baseTriple;
     if (floor !== undefined) {
         const own = releaseTriple(floor);
         if (own === undefined) {
-            throw new TypeError(`engineVersionTier: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
+            throw new TypeError(`${caller}: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
         }
         if (compareTriple(own, need) > 0)
             need = own;
@@ -40,3 +44,9 @@ export function engineVersionTier(version, floor) {
         return 'unknown';
     return compareTriple(got, need) >= 0 ? 'engine' : 'legacy';
 }
+export function engineVersionTier(version, floor) {
+    return versionTierAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier');
+}
+export function coreVersionTier(version, floor) {
+    return versionTierAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier');
+}

package/dist/taskRequestWords.d.ts

@@ -1,8 +1,9 @@
 import type { TaskRequest } from '@sema-agent/sdk';
 export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffort']>;
 export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
-export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto"];
+type SdkTaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
+export type TaskRequestPermissionMode = SdkTaskRequestPermissionMode | 'dontAsk';
+export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto", "dontAsk"];
 export interface RetiredAttachmentsKey {
     readonly key: string;
     readonly why: string;
@@ -10,3 +11,4 @@ export interface RetiredAttachmentsKey {
     readonly remedy: string;
 }
 export declare function retiredAttachmentsKeyOf(nameOrToken: string, form?: 'token' | 'key'): RetiredAttachmentsKey | undefined;
+export {};

package/dist/taskRequestWords.js

@@ -1,5 +1,5 @@
 export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
+export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto', 'dontAsk'];
 const _taskRequestWordPins = [true, true, true, true];
 void _taskRequestWordPins;
 export function retiredAttachmentsKeyOf(nameOrToken, form = 'token') {

package/dist/toolHistoryBadTurn.js

@@ -2,8 +2,7 @@ import { displayUntrusted } from './displayUntrusted.js';
 const BAD_TURN_PREVIEW_MAX = 60;
 export function toolHistoryBadTurnSentence(promptText) {
     const text = typeof promptText === 'string' ? promptText : '';
-    const flat = stripDisplayTagBlocks(text).replace(/\s+/g, ' ').trim();
-    const washed = displayUntrusted(flat, { foldLines: false, mark: 'dot' });
+    const washed = displayUntrusted(stripDisplayTagBlocks(text), { mark: 'dot' }).replace(/\s+/g, ' ').trim();
     const points = Array.from(washed);
     const preview = points.length > BAD_TURN_PREVIEW_MAX ? `${points.slice(0, BAD_TURN_PREVIEW_MAX).join('')}...` : washed;
     return preview.length > 0

package/dist/toolResult.d.ts

@@ -15,6 +15,8 @@ export declare const PROTOCOL_MARKERS: {
     readonly delegationTrailerFork: "Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.";
     readonly taskOutputLabel: RegExp;
     readonly taskOutputStatus: RegExp;
+    readonly taskOutputHeadSlots: RegExp;
+    readonly taskOutputResultNote: RegExp;
     readonly taskOutputNoneSentinel: "(none)";
     readonly taskOutputStdoutLine: RegExp;
     readonly taskOutputStderrLine: RegExp;
@@ -62,10 +64,16 @@ export type ModelFacingTaskOutput = {
     taskId?: string | undefined;
     status?: string | undefined;
     output: string;
+    state?: string;
+    error?: string;
+    resultNote?: string;
+    headRest?: string;
 } | {
     kind: 'unknown';
     taskId?: string | undefined;
     status?: string | undefined;
+    state?: string;
+    error?: string;
 };
 export declare function parseModelFacingTaskOutput(text: string): ModelFacingTaskOutput;
 export declare function backgroundReceiptParseCalls(): number;
@@ -92,7 +100,8 @@ export interface EngineBgShellRegistration {
     receipt: string;
     source: 'bash' | 'monitor';
 }
-export declare function detectEngineBgShellReceipt(toolName: string, rawInput: unknown, outputText: string | undefined): EngineBgShellRegistration | null;
+export declare function detectEngineBgShellReceipt(toolName: string, rawInput: unknown, outputText: string | undefined, structured?: unknown): EngineBgShellRegistration | null;
+export declare function detectEngineBgShellDetach(toolName: string, rawInput: unknown, structured: unknown, outputText: string | undefined): EngineBgShellRegistration | null;
 export declare function todoWriteToolUseResult(rawInput: unknown, oldTodos: unknown[], isError: boolean): {
     toolUseResult: unknown;
     isError: boolean;

package/dist/toolResult.js

@@ -30,6 +30,8 @@ export const PROTOCOL_MARKERS = {
     delegationTrailerFork: 'Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.',
     taskOutputLabel: /^TaskOutput\s+(\S+)$/,
     taskOutputStatus: /^status:\s*(.+)$/m,
+    taskOutputHeadSlots: /^(\r?\n)(?:(state: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?(?:(error: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?/,
+    taskOutputResultNote: /^--- result \(([^)\n]*)\) ---/,
     taskOutputNoneSentinel: '(none)',
     taskOutputStdoutLine: /^--- (?:new )?stdout[^\n]*---\n?/m,
     taskOutputStderrLine: /^--- (?:new )?stderr[^\n]*---\n?/m,
@@ -140,7 +142,8 @@ export function parseModelFacingTaskOutput(text) {
     const fence = stripUntrustedFence(text);
     const body = fence ? fence.body : text;
     const taskId = fence ? PROTOCOL_MARKERS.taskOutputLabel.exec(fence.label)?.[1] : undefined;
-    const status = PROTOCOL_MARKERS.taskOutputStatus.exec(body)?.[1]?.trim();
+    const mStatus = PROTOCOL_MARKERS.taskOutputStatus.exec(body);
+    const status = mStatus?.[1]?.trim();
     const none = (s) => {
         const t = s.replace(/\n$/, '');
         return t === PROTOCOL_MARKERS.taskOutputNoneSentinel ? '' : t;
@@ -159,9 +162,50 @@ export function parseModelFacingTaskOutput(text) {
     }
     const mRes = PROTOCOL_MARKERS.taskOutputResultLine.exec(body);
     if (mRes) {
-        return { kind: 'agent', taskId, status, output: body.slice(mRes.index + mRes[0].length).trimEnd() };
+        const lead = taskOutputHeadOf(body, mStatus, mRes.index);
+        const statusEnd = lead === null || mStatus === null ? 0 : mStatus[0].length;
+        const rest = lead === null ? body.slice(0, mRes.index) : body.slice(statusEnd + lead.consumed, mRes.index);
+        const resultNote = PROTOCOL_MARKERS.taskOutputResultNote.exec(mRes[0])?.[1];
+        return {
+            kind: 'agent',
+            taskId,
+            status,
+            output: body.slice(mRes.index + mRes[0].length).trimEnd(),
+            ...(lead?.state !== undefined ? { state: lead.state } : {}),
+            ...(lead?.error !== undefined ? { error: lead.error } : {}),
+            ...(resultNote !== undefined ? { resultNote } : {}),
+            ...(rest !== '' ? { headRest: rest } : {}),
+        };
     }
-    return { kind: 'unknown', taskId, status };
+    const lead = taskOutputHeadOf(body, mStatus, body.length);
+    return {
+        kind: 'unknown',
+        taskId,
+        status,
+        ...(lead?.state !== undefined ? { state: lead.state } : {}),
+        ...(lead?.error !== undefined ? { error: lead.error } : {}),
+    };
+}
+function taskOutputHeadOf(body, status, limit) {
+    if (status === null || status.index !== 0 || /[^\S \t]/.test(status[0]))
+        return null;
+    const head = PROTOCOL_MARKERS.taskOutputHeadSlots.exec(body.slice(status.index + status[0].length, limit));
+    if (head === null)
+        return null;
+    let consumed = head[1]?.length ?? 0;
+    let state;
+    let error;
+    if (head[2] !== undefined) {
+        if ((head[3] ?? '').trim() === '')
+            return { consumed };
+        state = head[3];
+        consumed += head[2].length;
+    }
+    if (head[4] !== undefined && (head[5] ?? '').trim() !== '') {
+        error = head[5];
+        consumed += head[4].length;
+    }
+    return { ...(state !== undefined ? { state } : {}), ...(error !== undefined ? { error } : {}), consumed };
 }
 const THREE_GEN_BG_RECEIPT_RE = /^(?:Started in background|Command running in background|Command moved to background); task_id=([A-Za-z0-9_-]+)/;
 const MONITOR_BG_RECEIPT_RE = /^Monitoring in background; task_id=([A-Za-z0-9_-]+)/;
@@ -630,7 +674,7 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
             return null;
     }
 }
-export function detectEngineBgShellReceipt(toolName, rawInput, outputText) {
+export function detectEngineBgShellReceipt(toolName, rawInput, outputText, structured) {
     if (typeof outputText !== 'string')
         return null;
     const input = (rawInput ?? {});
@@ -639,6 +683,8 @@ export function detectEngineBgShellReceipt(toolName, rawInput, outputText) {
     if (toolName === 'Bash') {
         if (input.run_in_background !== true)
             return null;
+        if (readBashDetachView(structured)?.registerFailed === true)
+            return null;
         m = THREE_GEN_BG_RECEIPT_RE.exec(outputText);
         source = 'bash';
     }
@@ -651,17 +697,45 @@ export function detectEngineBgShellReceipt(toolName, rawInput, outputText) {
     }
     if (!m?.[1])
         return null;
+    return engineBgShellRegistrationBody(m[1], input, outputText, source);
+}
+function engineBgShellRegistrationBody(taskId, rawInput, receipt, source) {
+    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: m[1],
+        taskId,
         command,
         ...(description !== undefined ? { description } : {}),
-        receipt: outputText,
+        receipt,
         source,
     };
 }
+export function detectEngineBgShellDetach(toolName, rawInput, structured, outputText) {
+    if (toolName !== 'Bash')
+        return null;
+    const view = readBashDetachView(structured);
+    if (view === null || !view.detached || view.registerFailed || view.taskId === undefined)
+        return null;
+    return engineBgShellRegistrationBody(view.taskId, rawInput, typeof outputText === 'string' ? outputText : '', 'bash');
+}
+function readBashDetachView(structured) {
+    if (typeof structured !== 'object' || structured === null)
+        return null;
+    const s = structured;
+    const type = s.type;
+    if (type !== 'bash')
+        return null;
+    const detached = s.detached;
+    const registerFailed = s.registerFailed;
+    const taskId = s.task_id;
+    return {
+        detached: detached === true,
+        registerFailed: registerFailed === true,
+        taskId: typeof taskId === 'string' && taskId.length > 0 ? taskId : undefined,
+    };
+}
 export function todoWriteToolUseResult(rawInput, oldTodos, isError) {
     const todos = rawInput?.todos;
     if (!Array.isArray(todos))

package/dist/types/engineState.d.ts

@@ -1,15 +1,5 @@
-export interface HealthResponse {
-    status: string;
-    model?: string;
-    sessionBackend?: string;
-    sessions?: number;
-    instanceId?: string;
-    dataRoot?: string;
-    configHash?: string;
-    pid?: number;
-    port?: number;
-    restartRequired?: boolean;
-    version?: string;
+import type { EngineHealth } from '@sema-agent/sdk';
+export interface HealthResponse extends Pick<EngineHealth, 'status' | 'model' | 'sessionBackend' | 'sessions' | 'instanceId' | 'dataRoot' | 'configHash' | 'pid' | 'port' | 'restartRequired' | 'version'> {
 }
 export interface EnginePortFile {
     port: number;

package/dist/userInvokedSkillsCapability.d.ts

@@ -0,0 +1,18 @@
+export type UserInvokedSkillsReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectUserInvokedSkillsCapability(caps: unknown): UserInvokedSkillsReading | undefined;
+export declare function noteEngineCapsForUserInvokedSkills(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedUserInvokedSkills(baseUrl?: string | undefined): UserInvokedSkillsReading;
+export declare function userInvokedSkillsAvailable(reading: UserInvokedSkillsReading): 'yes' | 'no' | 'unknown';
+export declare function userInvokedSkillsDoctorDetail(reading: UserInvokedSkillsReading): string;
+export declare function forgetUserInvokedSkillsReading(baseUrl: string | undefined): void;
+export declare function __resetUserInvokedSkillsReadingsForTests(): void;

package/dist/userInvokedSkillsCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectUserInvokedSkillsCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'userInvokedSkills'))
+        return { kind: 'not_reported' };
+    const v = caps.userInvokedSkills;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'userInvokedSkills',
+    project: projectUserInvokedSkillsCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForUserInvokedSkills(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedUserInvokedSkills(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function userInvokedSkillsAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+        return 'no';
+    return 'unknown';
+}
+export function userInvokedSkillsDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
+        case 'not_reported':
+            return 'user-invoked skills not reported by this engine — the engine predates it, so naming skills on a request is refused (do not send the key)';
+        case 'absent':
+            return 'user-invoked skills off on this deployment — naming skills on a request is not accepted';
+        case 'present':
+            return 'user-invoked skills on — skills the user names on a request take effect when the run starts';
+    }
+}
+export function forgetUserInvokedSkillsReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetUserInvokedSkillsReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/webSearchBackendCapability.js

@@ -38,9 +38,9 @@ export function webSearchBackendDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('deployment default backend not observed — the engine reports it on /v1/capabilities; ' +
-                'this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)');
+                'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
-            return ('deployment default backend not reported by this engine — only newer engines advertise it; ' +
+            return ('deployment default backend not reported by this engine; ' +
                 'this does not say whether the deployment has a search backend');
         case 'none':
             return (`deployment default backend none — ${DEPLOY_ENV} is unset or not a provider word on the engine, ` +

package/dist/webSearchWireCaps.d.ts

@@ -22,7 +22,7 @@ export type WebSearchSettingsVerdict = {
     settings: WebSearchSettings;
 } | {
     kind: 'malformed';
-    source: 'env' | 'settings';
+    source: 'env' | 'settings' | 'host';
     field: WebSearchSettingsField;
     issue: string;
 };

package/dist/webSearchWireCaps.js

@@ -32,6 +32,37 @@ function judgeText(raw) {
         return { ok: false, issue: 'must be a string' };
     return { ok: true, value: isBlankText(raw) ? undefined : raw };
 }
+const API_KEY_ISSUE = 'must be usable as an HTTP header value (it contains a character an HTTP header cannot carry, such as a line break)';
+const isHttpWhitespaceCode = (c) => c === 0x09 || c === 0x0a || c === 0x0d || c === 0x20;
+function isHttpHeaderValue(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && isHttpWhitespaceCode(value.charCodeAt(start)))
+        start++;
+    while (end > start && isHttpWhitespaceCode(value.charCodeAt(end - 1)))
+        end--;
+    for (let i = start; i < end; i++) {
+        const c = value.charCodeAt(i);
+        if (!(c === 0x09 || (c >= 0x20 && c <= 0x7e) || (c >= 0x80 && c <= 0xff)))
+            return false;
+    }
+    return true;
+}
+function apiKeyHeaderValue(provider, key) {
+    switch (provider) {
+        case 'brave':
+        case 'searxng':
+            return key;
+        case 'tavily':
+            return `Bearer ${key}`;
+    }
+}
+function judgeApiKey(provider, raw) {
+    const text = judgeText(raw);
+    if (!text.ok || text.value === undefined)
+        return text;
+    return isHttpHeaderValue(apiKeyHeaderValue(provider, text.value)) ? text : { ok: false, issue: API_KEY_ISSUE };
+}
 const ENDPOINT_ISSUE = 'must be an absolute URL with a scheme and a host, such as https://search.example.com (a bare host or host:port is not one)';
 function judgeEndpoint(raw) {
     if (raw === undefined || raw === null)
@@ -114,9 +145,10 @@ function judgeSection(raw, source, apiKeyFor) {
             injected = undefined;
         }
     }
-    const apiKey = typeof injected === 'string' && !isBlankText(injected) ? { ok: true, value: injected } : judgeText(s.apiKey);
+    const useInjected = typeof injected === 'string' && !isBlankText(injected);
+    const apiKey = judgeApiKey(provider.value, useInjected ? injected : s.apiKey);
     if (!apiKey.ok)
-        return { kind: 'malformed', source, field: 'apiKey', issue: apiKey.issue };
+        return { kind: 'malformed', source: useInjected ? 'host' : source, field: 'apiKey', issue: apiKey.issue };
     const endpoint = judgeEndpoint(s.endpoint);
     if (!endpoint.ok)
         return { kind: 'malformed', source, field: 'endpoint', issue: endpoint.issue };
@@ -191,6 +223,12 @@ function envNameOfField(field) {
 export function webSearchVerdictMessage(verdict, context = 'submit') {
     if (verdict.kind !== 'malformed')
         return undefined;
+    if (verdict.source === 'host') {
+        const head = `Web search is misconfigured: the API key your host supplied for webSearch is malformed; it ${verdict.issue}.`;
+        return context === 'submit'
+            ? `${head} The request was not sent — the key needs replacing where your host keeps it.`
+            : `${head} Requests will be refused until the key is replaced where your host keeps it.`;
+    }
     const where = verdict.source === 'env' ? envNameOfField(verdict.field) : verdict.field === 'section' ? 'the webSearch section in settings' : `webSearch.${verdict.field} in settings`;
     const fix = verdict.source === 'env' ? 'fix it or unset the SEMA_WEBSEARCH_* variables' : 'fix it or remove the webSearch section';
     return context === 'submit'

package/dist/wireFailureShape.d.ts

@@ -5,6 +5,8 @@ interface WireFailureShape {
     committed?: 'no' | 'unknown' | 'unreadable';
     bodyField?: string;
     bodyName?: string;
+    bodyVerdict?: string;
+    bodyCurrentName?: string;
     message: string;
 }
 export declare function readErrorNumber(o: object, key: string): number | undefined;

package/dist/wireFailureShape.js

@@ -66,9 +66,9 @@ export function readErrorStrictStringList(o, key) {
         return true;
     };
     const v = readErrorSlot(o, key, strict);
-    if (!Array.isArray(v))
-        return undefined;
     try {
+        if (!Array.isArray(v))
+            return undefined;
         const out = [];
         const len = v.length;
         for (let i = 0; i < len; i++) {
@@ -131,6 +131,8 @@ export function wireFailureShapeOf(e) {
     };
     const bodyField = ownString('field');
     const bodyName = ownString('name');
+    const bodyVerdict = ownString('verdict');
+    const bodyCurrentName = ownString('currentName');
     let message;
     try {
         message = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : String(e);
@@ -155,6 +157,8 @@ export function wireFailureShapeOf(e) {
         ...(committed !== undefined ? { committed } : {}),
         ...(bodyField !== undefined ? { bodyField } : {}),
         ...(bodyName !== undefined ? { bodyName } : {}),
+        ...(bodyVerdict !== undefined ? { bodyVerdict } : {}),
+        ...(bodyCurrentName !== undefined ? { bodyCurrentName } : {}),
         message,
     };
 }