@sema-agent/client-core 0.85.2 → 0.86.0

package/dist/centerWiringCapability.d.ts

@@ -0,0 +1,38 @@
+export interface CenterWiringRevisionView {
+    version: number;
+    updatedAt: string;
+}
+export interface CenterWiringCallerView {
+    lease: string;
+    retryAfterSec?: number;
+}
+export interface CenterWiringView {
+    effectivePull: boolean;
+    effectiveRevision: CenterWiringRevisionView | null;
+    lease: string;
+    leaseHealth?: string;
+    failMode?: string;
+    usageReport: boolean;
+    issuer: string;
+    caller?: CenterWiringCallerView;
+}
+export type CenterWiringReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'none';
+} | {
+    kind: 'present';
+    view: CenterWiringView;
+};
+export declare function projectCenterWiringCapability(caps: unknown): CenterWiringReading | undefined;
+export declare function noteEngineCapsForCenterWiring(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedCenterWiring(baseUrl?: string | undefined): CenterWiringReading;
+export type CallerQuotaLease = 'enforced' | 'not-enforced' | 'exhausted' | 'unobserved' | 'no-lease' | 'unknown';
+export declare function callerQuotaLease(reading: CenterWiringReading): CallerQuotaLease;
+export declare function centerWiringDoctorDetail(reading: CenterWiringReading): string;
+export declare function forgetCenterWiringReading(baseUrl: string | undefined): void;
+export declare function __resetCenterWiringReadingsForTests(): void;

package/dist/centerWiringCapability.js

@@ -0,0 +1,202 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function optionalSeat(o, key) {
+    if (!Object.hasOwn(o, key))
+        return { state: 'absent' };
+    const value = o[key];
+    return value === undefined ? { state: 'absent' } : { state: 'value', value };
+}
+export function projectCenterWiringCapability(caps) {
+    try {
+        return projectCenterWiringOf(caps);
+    }
+    catch {
+        return undefined;
+    }
+}
+function projectCenterWiringOf(caps) {
+    if (!isPlainObject(caps))
+        return undefined;
+    const cw = Object.hasOwn(caps, 'centerWiring') ? caps.centerWiring : undefined;
+    if (cw === undefined)
+        return capsGenerationOf(caps).generation === 'new' ? { kind: 'none' } : { kind: 'not_reported' };
+    if (!isPlainObject(cw))
+        return undefined;
+    const effectivePull = cw.effectivePull;
+    const revisionRaw = cw.effectiveRevision;
+    const lease = cw.lease;
+    const usageReport = cw.usageReport;
+    const issuer = cw.issuer;
+    if (typeof effectivePull !== 'boolean' || typeof usageReport !== 'boolean')
+        return undefined;
+    if (!nonEmpty(lease) || !nonEmpty(issuer))
+        return undefined;
+    let effectiveRevision;
+    if (revisionRaw === null) {
+        effectiveRevision = null;
+    }
+    else {
+        if (!isPlainObject(revisionRaw))
+            return undefined;
+        const version = revisionRaw.version;
+        const updatedAt = revisionRaw.updatedAt;
+        if (typeof version !== 'number' || !Number.isFinite(version) || !nonEmpty(updatedAt))
+            return undefined;
+        effectiveRevision = { version, updatedAt };
+    }
+    const health = optionalSeat(cw, 'leaseHealth');
+    if (health.state === 'value' && !nonEmpty(health.value))
+        return undefined;
+    const mode = optionalSeat(cw, 'failMode');
+    if (mode.state === 'value' && !nonEmpty(mode.value))
+        return undefined;
+    const callerSeat = optionalSeat(cw, 'caller');
+    let caller;
+    if (callerSeat.state === 'value') {
+        if (!isPlainObject(callerSeat.value))
+            return undefined;
+        const callerLease = callerSeat.value.lease;
+        if (!nonEmpty(callerLease))
+            return undefined;
+        const wait = optionalSeat(callerSeat.value, 'retryAfterSec');
+        if (wait.state === 'value' && (typeof wait.value !== 'number' || !Number.isFinite(wait.value) || wait.value < 0))
+            return undefined;
+        caller = { lease: callerLease, ...(wait.state === 'value' ? { retryAfterSec: wait.value } : {}) };
+    }
+    return {
+        kind: 'present',
+        view: {
+            effectivePull,
+            effectiveRevision,
+            lease,
+            ...(health.state === 'value' ? { leaseHealth: health.value } : {}),
+            ...(mode.state === 'value' ? { failMode: mode.value } : {}),
+            usageReport,
+            issuer,
+            ...(caller !== undefined ? { caller } : {}),
+        },
+    };
+}
+const reader = createEngineCapReader({
+    name: 'centerWiring',
+    project: projectCenterWiringCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForCenterWiring(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedCenterWiring(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+function guarded(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    try {
+        const kind = reading.kind;
+        if (kind === 'not_reported' || kind === 'unobserved' || kind === 'none')
+            return { kind };
+        if (kind !== 'present')
+            return undefined;
+        const view = reading.view;
+        return isPlainObject(view) ? { kind: 'present', view } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function callerQuotaLease(reading) {
+    const r = guarded(reading);
+    if (r === undefined)
+        return 'unknown';
+    if (r.kind === 'none')
+        return 'no-lease';
+    if (r.kind !== 'present')
+        return 'unknown';
+    try {
+        const lease = r.view.lease;
+        if (lease === 'absent')
+            return 'no-lease';
+        if (lease !== 'configured')
+            return 'unknown';
+        const caller = r.view.caller;
+        if (!isPlainObject(caller))
+            return 'unknown';
+        const callerLease = caller.lease;
+        return callerLease === 'enforced' || callerLease === 'not-enforced' || callerLease === 'exhausted' || callerLease === 'unobserved' ? callerLease : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const WORD_DETAIL_MAX = 40;
+const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
+function healthClause(v) {
+    if (v === undefined)
+        return 'lease health not reported';
+    if (v === 'ok')
+        return 'the quota service is answering';
+    if (v === 'auth-rejected')
+        return "the quota service rejected this engine's credentials";
+    if (v === 'unreachable')
+        return 'the quota service could not be reached';
+    if (v === 'unobserved')
+        return 'no lease negotiated yet';
+    return nonEmpty(v) ? `lease health reported as "${word(v)}"` : 'lease health not reported';
+}
+function failModeClause(v) {
+    if (v === undefined)
+        return 'failure posture not reported';
+    if (v === 'closed')
+        return 'billed requests are refused while a budget cannot be confirmed';
+    if (v === 'open')
+        return 'billed requests are let through while a budget cannot be confirmed';
+    return nonEmpty(v) ? `failure posture reported as "${word(v)}"` : 'failure posture not reported';
+}
+export function centerWiringDoctorDetail(reading) {
+    const unobserved = 'center wiring not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this engine is connected to a configuration center is unknown';
+    const r = guarded(reading);
+    if (r?.kind === 'not_reported') {
+        return 'center wiring not reported by this engine — only newer engines advertise it; this does not say whether the engine is connected to a configuration center';
+    }
+    if (r?.kind === 'none') {
+        return 'no configuration center on this deployment — the engine runs on its own local configuration; no quota lease or usage reporting goes through a center';
+    }
+    if (r?.kind !== 'present')
+        return unobserved;
+    try {
+        const v = r.view;
+        const pull = v.effectivePull === true ? 'configuration pulled from the center' : 'latest configuration pull did not succeed (running on what it already had)';
+        const rev = v.effectiveRevision;
+        const revision = isPlainObject(rev) && typeof rev.version === 'number' && Number.isFinite(rev.version) ? `revision ${String(rev.version)} in effect` : 'no revision in effect yet';
+        const lease = v.lease;
+        const leasePart = lease === 'absent'
+            ? 'quota lease not configured'
+            : lease === 'configured'
+                ? `quota lease configured (${healthClause(v.leaseHealth)}; ${failModeClause(v.failMode)})`
+                : nonEmpty(lease)
+                    ? `quota lease reported as "${word(lease)}"`
+                    : 'quota lease not reported';
+        const usage = v.usageReport === true ? 'usage reporting on' : 'usage reporting off';
+        const iss = v.issuer;
+        const issuer = iss === 'explicit'
+            ? 'token issuer set explicitly'
+            : iss === 'fallback'
+                ? 'token issuer defaults to the center'
+                : nonEmpty(iss)
+                    ? `token issuer reported as "${word(iss)}"`
+                    : 'token issuer not reported';
+        return `connected to a configuration center — ${pull}, ${revision} · ${leasePart} · ${usage} · ${issuer}`;
+    }
+    catch {
+        return unobserved;
+    }
+}
+export function forgetCenterWiringReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetCenterWiringReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/decideFailureNote.js

@@ -1,13 +1,16 @@
 import { corruptStoredRowContent, corruptStoredRowWhere } from './wireErrorTriage.js';
 import { parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
+import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
+    const bucket = settingsPermissionBucketRefusalFromError(err);
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
+        (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`));
 }

package/dist/engineCapReader.d.ts

@@ -12,4 +12,12 @@ interface EngineCapReader<R> {
     __resetForTests(): void;
 }
 export declare function createEngineCapReader<R>(spec: EngineCapReaderSpec<R>): EngineCapReader<R>;
+export type CapsGeneration = {
+    generation: 'new';
+    store: object;
+} | {
+    generation: 'old';
+    store: 'absent' | 'malformed';
+};
+export declare function capsGenerationOf(caps: object): CapsGeneration;
 export {};

package/dist/engineCapReader.js

@@ -43,3 +43,18 @@ export function createEngineCapReader(spec) {
         },
     };
 }
+export function capsGenerationOf(caps) {
+    try {
+        if (!Object.hasOwn(caps, 'store'))
+            return { generation: 'old', store: 'absent' };
+        const store = caps.store;
+        if (store === undefined)
+            return { generation: 'old', store: 'absent' };
+        if (typeof store !== 'object' || store === null || Array.isArray(store))
+            return { generation: 'old', store: 'malformed' };
+        return { generation: 'new', store };
+    }
+    catch {
+        return { generation: 'old', store: 'malformed' };
+    }
+}

package/dist/engineErrorCodes.d.ts

@@ -5,6 +5,7 @@ export declare const LIMITS_MAX_WALLTIME_EXCEEDED = "limits.max_walltime_exceede
 export declare function isLimitsExceededCode(code: string | undefined): boolean;
 export declare const USAGE_WINDOW_EXHAUSTED = "usage.window_exhausted";
 export declare const ENV_LIFETIME_EXPIRED = "env.lifetime_expired";
+export declare const FLEET_LEASE_UNAVAILABLE = "fleet.lease_unavailable";
 export declare const CONFIG_LIMIT_INVALID = "config.limit_invalid";
 export declare const CONFIG_STRATEGY_FIND_LIMIT_INVALID = "config.strategy_find_limit_invalid";
 export declare const CONFIG_STRATEGY_MAX_SIZE_INVALID = "config.strategy_max_size_invalid";
@@ -14,6 +15,8 @@ export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
 export declare const CONFIG_REFUSAL_CODES: ReadonlySet<string>;
+export declare const RULES_LEGACY_TOOL_NAME = "rules.legacy_tool_name";
+export declare function isRulesRefusalCode(code: string | undefined): boolean;
 export declare const DELEGATION_CONCURRENCY_CAP = "delegation.concurrency_cap";
 export declare const DELEGATION_SESSION_CAP = "delegation.session_cap";
 export declare const DELEGATION_CAP_CODES: ReadonlySet<string>;

package/dist/engineErrorCodes.js

@@ -1,4 +1,5 @@
 import { frozenSet } from './frozenSet.js';
+import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -9,6 +10,7 @@ export function isLimitsExceededCode(code) {
 }
 export const USAGE_WINDOW_EXHAUSTED = 'usage.window_exhausted';
 export const ENV_LIFETIME_EXPIRED = 'env.lifetime_expired';
+export const FLEET_LEASE_UNAVAILABLE = 'fleet.lease_unavailable';
 export const CONFIG_LIMIT_INVALID = 'config.limit_invalid';
 export const CONFIG_STRATEGY_FIND_LIMIT_INVALID = 'config.strategy_find_limit_invalid';
 export const CONFIG_STRATEGY_MAX_SIZE_INVALID = 'config.strategy_max_size_invalid';
@@ -26,7 +28,13 @@ export const CONFIG_REFUSAL_CODES = frozenSet([
     CONFIG_MEMORY_PROJECT_KEY_SPELLING,
     CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
     CONFIG_LEGACY_TOOL_NAME,
+    ...CORE_TOOL_DECLARATION_CODES,
 ]);
+export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
+const RULES_ERROR_CODE_PREFIX = 'rules.';
+export function isRulesRefusalCode(code) {
+    return typeof code === 'string' && code.startsWith(RULES_ERROR_CODE_PREFIX);
+}
 export const DELEGATION_CONCURRENCY_CAP = 'delegation.concurrency_cap';
 export const DELEGATION_SESSION_CAP = 'delegation.session_cap';
 export const DELEGATION_CAP_CODES = frozenSet([

package/dist/engineNoticeCodes.d.ts

@@ -19,6 +19,7 @@ export interface AskUnresolvableFactsView {
     toolCallId: string;
     cause: string;
     parkLaneExisted?: boolean;
+    remedy?: string;
 }
 export declare function readAskUnresolvable(notice: unknown): AskUnresolvableFactsView | undefined;
 export declare const DURABLE_MANDATE_SOURCES: readonly string[];
@@ -81,6 +82,61 @@ export interface SessionRecordsSkippedFactsView {
 }
 export declare function readSessionRecordsSkipped(notice: unknown): SessionRecordsSkippedFactsView | undefined;
 export declare function sessionRecordsSkippedNote(facts: Pick<SessionRecordsSkippedFactsView, 'entriesKept'>): string | undefined;
+export interface RuleStoreUnavailableFactsView {
+    at: string;
+    sessionId: string;
+    runId: string;
+}
+export declare function readRuleStoreUnavailable(notice: unknown): RuleStoreUnavailableFactsView | undefined;
+declare const CLASSIFIER_UNAVAILABLE_DISPOSITIONS: readonly ["asked", "denied"];
+type ClassifierUnavailableDispositionWord = (typeof CLASSIFIER_UNAVAILABLE_DISPOSITIONS)[number];
+export interface ClassifierUnavailableFactsView {
+    toolName: string;
+    toolCallId: string;
+    cause: string;
+    disposition: ClassifierUnavailableDispositionWord;
+    sessionId?: string;
+    runId?: string;
+}
+export declare function readClassifierUnavailable(notice: unknown): ClassifierUnavailableFactsView | undefined;
+export declare const PERMISSION_MODE_FOLD_REASONS: readonly string[];
+export interface PermissionModeUnavailableFactsView {
+    requested: string;
+    effective: string;
+    by: string;
+    sessionId: string;
+    runId: string;
+    childSessionId?: string;
+}
+export declare function readPermissionModeUnavailable(notice: unknown): PermissionModeUnavailableFactsView | undefined;
+export interface AskReleasedByModeFactsView {
+    mode: string;
+    askClass: string;
+    origin?: string;
+    mandate?: string;
+    count: number;
+    firstToolCallId: string;
+    sessionId?: string;
+    runId?: string;
+}
+export declare function readAskReleasedByMode(notice: unknown): AskReleasedByModeFactsView | undefined;
+export interface ReadDenyUnappliedFactsView {
+    mode: string;
+    toolCallId: string;
+    tiers: readonly string[];
+    rows: readonly string[];
+    rowCount: number;
+    sessionId: string;
+    runId: string;
+}
+export declare function readReadDenyUnapplied(notice: unknown): ReadDenyUnappliedFactsView | undefined;
+export interface LegacyModeSeedMigratedFactsView {
+    permissionMode?: string;
+    droppedKeys: readonly string[];
+    sessionId: string;
+    runId: string;
+}
+export declare function readLegacyModeSeedMigrated(notice: unknown): LegacyModeSeedMigratedFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -91,6 +147,12 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'approval.read_root_granted': typeof readReadRootGrantNotice;
     readonly 'approval.read_root_grant_rejected': typeof readReadRootGrantNotice;
     readonly 'session.records_skipped': typeof readSessionRecordsSkipped;
+    readonly 'permission.rule_store_unavailable': typeof readRuleStoreUnavailable;
+    readonly 'classifier.unavailable': typeof readClassifierUnavailable;
+    readonly 'config.permission_mode_unavailable': typeof readPermissionModeUnavailable;
+    readonly 'permission.ask_released_by_mode': typeof readAskReleasedByMode;
+    readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
+    readonly 'resume.legacy_mode_seed_migrated': typeof readLegacyModeSeedMigrated;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;