@sema-agent/client-core 0.87.0 → 0.89.0

package/dist/adapter/activeRunSelfHeal.js

@@ -1,5 +1,6 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
+import { steeringRefusedBeforeEngine, steeringStatusIs4xx } from '../controlRouter.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 export const PLAN_REVIEW_GATE_KINDS = Object.freeze([PLAN_REVIEW_GATE_KIND, 'dry_run_review']);
 export const ASK_PARK_GATE_KINDS = Object.freeze(['human', 'irreversible_ask', 'policy_ask', 'tool_approval']);
@@ -260,8 +261,9 @@ function reopenedOfOutcome(outcome) {
     }
 }
 export function atMostOnceFailureClass(e) {
-    const status = errorSlot(e, 'status');
-    return typeof status === 'number' && status >= 400 && status < 500 ? 'rejected' : 'unknown';
+    if (typeof e === 'object' && e !== null && steeringStatusIs4xx(e))
+        return 'rejected';
+    return typeof e === 'object' && e !== null && steeringRefusedBeforeEngine(e) !== undefined ? 'rejected' : 'unknown';
 }
 export function readSteerDelivery(receipt) {
     try {

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -1,4 +1,4 @@
-import { wiringManifestViewOf } from './wiringManifestView.js';
+import { readInstructionsSegment, wiringManifestViewOf } from './wiringManifestView.js';
 import { stamp, snapshotSegmentIdentity, } from '../types.js';
 import { turnUsageToModelUsage } from './turnUsageToModelUsage.js';
 import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js';
@@ -549,7 +549,9 @@ function wiringManifestSupersetBody(ev) {
     const autoConsolidation = projectAutoConsolidationSection(ev.autoConsolidation);
     const readDeny = projectReadDenySection(ev.readDeny);
     const hands = projectHandsSection(ev);
-    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined)
+    const fileHistory = projectFileHistorySection(ev);
+    const instructions = readInstructionsSegment(ev, 'instructions');
+    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined)
         return undefined;
     return {
         ...(modelGate !== undefined ? { _sema_modelGate: modelGate } : {}),
@@ -562,8 +564,21 @@ function wiringManifestSupersetBody(ev) {
         ...(autoConsolidation !== undefined ? { _sema_autoConsolidation: autoConsolidation } : {}),
         ...(readDeny !== undefined ? { _sema_readDeny: readDeny } : {}),
         ...(hands !== undefined ? { _sema_hands: hands } : {}),
+        ...(fileHistory !== undefined ? { _sema_fileHistory: fileHistory } : {}),
+        ...(instructions !== undefined ? { _sema_instructions: instructions } : {}),
     };
 }
+function projectFileHistorySection(holder) {
+    try {
+        if (!Object.hasOwn(holder, 'fileHistory'))
+            return undefined;
+        const raw = holder.fileHistory;
+        return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function projectWriteProtectionSection(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return undefined;

package/dist/adapter/downstream/wiringManifestView.d.ts

@@ -11,6 +11,10 @@ export type WiringManifestSections = {
     _sema_autoConsolidation?: WiringManifestAutoConsolidationView;
     _sema_readDeny?: WiringManifestReadDenyView;
     _sema_hands?: WiringManifestHandsView;
+    _sema_fileHistory?: string;
+    _sema_instructions?: {
+        readonly selected: readonly string[];
+    };
     eventId?: string;
 };
 export interface WiringManifestView {
@@ -24,6 +28,13 @@ export interface WiringManifestView {
     autoConsolidation?: WiringManifestAutoConsolidationView;
     readDeny?: WiringManifestReadDenyView;
     hands?: WiringManifestHandsView;
+    fileHistory?: string;
+    instructions?: {
+        readonly selected: readonly string[];
+    };
     eventId?: string;
 }
+export declare function readInstructionsSegment(holder: object, key: 'instructions' | '_sema_instructions'): {
+    readonly selected: readonly string[];
+} | undefined;
 export declare function wiringManifestViewOf(s: WiringManifestSections): WiringManifestView | undefined;

package/dist/adapter/downstream/wiringManifestView.js

@@ -2,8 +2,34 @@ const _viewPin = true;
 void _viewPin;
 const _viewKeysPin = true;
 void _viewKeysPin;
+export function readInstructionsSegment(holder, key) {
+    try {
+        if (!Object.hasOwn(holder, key))
+            return undefined;
+        const raw = holder[key];
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw) || !Object.hasOwn(raw, 'selected'))
+            return undefined;
+        const sel = raw.selected;
+        if (!Array.isArray(sel))
+            return undefined;
+        const out = [];
+        for (let i = 0; i < sel.length; i++) {
+            if (!Object.hasOwn(sel, i))
+                return undefined;
+            const v = sel[i];
+            if (typeof v !== 'string' || v.length === 0)
+                return undefined;
+            out.push(v);
+        }
+        return Object.freeze({ selected: Object.freeze(out) });
+    }
+    catch {
+        return undefined;
+    }
+}
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export function wiringManifestViewOf(s) {
+    const instructions = readInstructionsSegment(s, '_sema_instructions');
     const view = {
         ...(isObj(s._sema_modelGate) ? { modelGate: s._sema_modelGate } : {}),
         ...(isObj(s._sema_autoMode) ? { autoMode: s._sema_autoMode } : {}),
@@ -15,6 +41,8 @@ export function wiringManifestViewOf(s) {
         ...(isObj(s._sema_autoConsolidation) ? { autoConsolidation: s._sema_autoConsolidation } : {}),
         ...(isObj(s._sema_readDeny) ? { readDeny: s._sema_readDeny } : {}),
         ...(isObj(s._sema_hands) && typeof s._sema_hands.mounted === 'boolean' ? { hands: s._sema_hands } : {}),
+        ...(typeof s._sema_fileHistory === 'string' && s._sema_fileHistory.length > 0 ? { fileHistory: s._sema_fileHistory } : {}),
+        ...(instructions !== undefined ? { instructions } : {}),
     };
     if (Object.keys(view).length === 0)
         return undefined;

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.d.ts

@@ -33,5 +33,9 @@ export interface DisplayUntrustedMarked {
     readonly text: string;
     readonly marks: readonly DisplayMarkSpan[];
 }
+export declare function credentialWashPasses(text: string, opts?: DisplayUntrustedOptions | null): {
+    passes: number;
+    capped: boolean;
+};
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
 export declare function displayUntrustedMarks(text: string, opts?: DisplayUntrustedOptions): DisplayUntrustedMarked;