@sema-agent/client-core 0.85.1 → 0.86.0

package/dist/storePostureCapability.js

@@ -0,0 +1,132 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { projectSqlEngineCapability } from './sqlEngineCapability.js';
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+export function projectStorePostureCapability(caps) {
+    try {
+        return projectStorePostureOf(caps);
+    }
+    catch {
+        return undefined;
+    }
+}
+function projectStorePostureOf(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    const gen = capsGenerationOf(caps);
+    if (gen.generation === 'old')
+        return gen.store === 'absent' ? { kind: 'not_reported' } : undefined;
+    const store = gen.store;
+    const s = store;
+    const declared = s.declared;
+    const backend = s.backend;
+    const durable = s.durable;
+    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+        return undefined;
+    const hasReason = Object.hasOwn(store, 'degradedReason');
+    const reason = hasReason ? s.degradedReason : undefined;
+    if (hasReason && reason !== undefined && !nonEmpty(reason))
+        return undefined;
+    const sqlReading = projectSqlEngineCapability({ store });
+    if (sqlReading === undefined)
+        return undefined;
+    return {
+        kind: 'present',
+        view: {
+            declared,
+            backend,
+            durable,
+            ...(nonEmpty(reason) ? { degradedReason: reason } : {}),
+            ...(sqlReading.kind === 'present' ? { sql: sqlReading.view } : {}),
+        },
+    };
+}
+const reader = createEngineCapReader({
+    name: 'store',
+    project: projectStorePostureCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForStorePosture(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+function presentView(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    try {
+        const kind = reading.kind;
+        if (kind === 'not_reported' || kind === 'unobserved')
+            return { kind };
+        if (kind !== 'present')
+            return undefined;
+        const view = reading.view;
+        if (typeof view !== 'object' || view === null)
+            return undefined;
+        return { kind: 'present', view: view };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function storePersistence(reading) {
+    const r = presentView(reading);
+    if (r?.kind !== 'present')
+        return 'unknown';
+    let durable;
+    try {
+        durable = r.view.durable;
+    }
+    catch {
+        return 'unknown';
+    }
+    return durable === true ? 'durable' : durable === false ? 'not_durable' : 'unknown';
+}
+const WORD_DETAIL_MAX = 40;
+const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
+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';
+    }
+    if (r?.kind !== 'present')
+        return unobserved;
+    let declared;
+    let backend;
+    let durable;
+    let reason;
+    try {
+        declared = r.view.declared;
+        backend = r.view.backend;
+        durable = r.view.durable;
+        reason = r.view.degradedReason;
+    }
+    catch {
+        return unobserved;
+    }
+    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+        return unobserved;
+    const assembled = declared === backend ? `store ${word(backend)}` : `store declared ${word(declared)}, running on ${word(backend)}`;
+    if (durable) {
+        return `${assembled} — durable: this replica persists its state, so it survives a restart`;
+    }
+    const lost = 'NOT durable: this replica holds its state in memory and loses it on restart';
+    if (!nonEmpty(reason))
+        return `${assembled} — ${lost}`;
+    if (reason === 'db_unreachable') {
+        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 for a reason this client does not know yet: "${word(reason)}")`;
+}
+export function forgetStorePostureReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetStorePostureReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/toolResult.js

@@ -3,53 +3,8 @@ import { markEngineWorkflowNotified, registerOutstandingBgTask, registerOutstand
 import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow.js';
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
-export const STRUCTURED_DETAIL_TYPES = frozenSet([
-    'edit',
-    'create',
-    'update',
-    'bash',
-    'notebook-edit',
-    'notebook',
-    'text',
-    'grep',
-    'glob',
-    'mcp',
-    'agent',
-    'task',
-    'task-list',
-    'task-output',
-    'workflow-run',
-    'web-fetch',
-    'web-search',
-    'todo',
-    'cron-create',
-    'cron-delete',
-    'cron-list',
-    'image',
-    'task-stop',
-    'tool-search',
-    'repo-map',
-    'fork',
-    'enter-plan-mode',
-    'exit-plan-mode',
-    'file_unchanged',
-    'worktree',
-    'monitor-start',
-    'path_not_in_root',
-    'readonly_out_of_root',
-    'report-findings',
-    'schedule-wakeup',
-    'send-message',
-    'agent-transcript',
-    'a2a',
-    'document',
-    'ask-question',
-    'bash_invalid_timeout',
-    'read_path_denied',
-    'list-agents',
-    'artifact',
-    'read-inbox',
-]);
+import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
+export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)
         return undefined;

package/dist/wireErrorTriage.d.ts

@@ -6,6 +6,7 @@ export type TurnWireErrorVerdict = {
     message: string;
     storedRowWhere?: string;
     sessionUnreadable?: true;
+    leaseUnavailable?: true;
 } | {
     kind: 'stream-ended-without-terminal';
 } | {

package/dist/wireErrorTriage.js

@@ -1,5 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
 import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
 function wireErrorDetail(err) {
@@ -16,6 +17,7 @@ export function classifyTurnWireError(err) {
         const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
         const storedRowWhere = corruptStoredRowWhere(err);
         const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
+        const leaseUnavailable = fleetLeaseUnavailableFromError(err) !== null;
         return {
             kind: 'http',
             status: e.status,
@@ -23,6 +25,7 @@ export function classifyTurnWireError(err) {
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
             ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
+            ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
         };
     }
     const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'

package/dist/wireFailureShape.d.ts

@@ -3,10 +3,13 @@ interface WireFailureShape {
     errorCode?: string;
     retryAfterSec?: number;
     committed?: 'no' | 'unknown' | 'unreadable';
+    bodyField?: string;
+    bodyName?: string;
     message: string;
 }
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorString(o: object, key: string): string | undefined;
 export declare function readErrorStringList(o: object, key: string): readonly string[] | undefined;
+export declare function readErrorStrictStringList(o: object, key: string): readonly string[] | undefined;
 export declare function wireFailureShapeOf(e: unknown): WireFailureShape;
 export {};

package/dist/wireFailureShape.js

@@ -52,6 +52,33 @@ export function readErrorStringList(o, key) {
     const v = readErrorSlot(o, key, (x) => Array.isArray(x));
     return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined;
 }
+export function readErrorStrictStringList(o, key) {
+    const strict = (x) => {
+        if (!Array.isArray(x))
+            return false;
+        for (let i = 0; i < x.length; i++)
+            if (typeof x[i] !== 'string')
+                return false;
+        return true;
+    };
+    const v = readErrorSlot(o, key, strict);
+    if (!Array.isArray(v))
+        return undefined;
+    try {
+        const out = [];
+        const len = v.length;
+        for (let i = 0; i < len; i++) {
+            const item = v[i];
+            if (typeof item !== 'string')
+                return undefined;
+            out.push(item);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function wireFailureShapeOf(e) {
     const o = e ?? {};
     const status = readGuarded(o, 'status');
@@ -85,6 +112,21 @@ export function wireFailureShapeOf(e) {
             }
         }
     }
+    const ownString = (key) => {
+        if (extraObj === undefined)
+            return undefined;
+        try {
+            if (!Object.hasOwn(extraObj, key))
+                return undefined;
+            const v = extraObj[key];
+            return typeof v === 'string' ? v : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const bodyField = ownString('field');
+    const bodyName = ownString('name');
     let message;
     try {
         message = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : String(e);
@@ -107,6 +149,8 @@ export function wireFailureShapeOf(e) {
         ...(typeof errorCode === 'string' ? { errorCode } : {}),
         ...(sec !== undefined ? { retryAfterSec: sec } : {}),
         ...(committed !== undefined ? { committed } : {}),
+        ...(bodyField !== undefined ? { bodyField } : {}),
+        ...(bodyName !== undefined ? { bodyName } : {}),
         message,
     };
 }

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,5 @@
-import { USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
 export type CancelConflictKind = 'approval_settled' | 'run_not_running' | 'unrecognized';
@@ -14,6 +15,13 @@ export interface UsageWindowExhaustedDetail {
 }
 export declare function usageWindowExhaustedFromError(err: unknown): UsageWindowExhaustedDetail | null;
 export declare function usageWindowExhaustedContent(detail: UsageWindowExhaustedDetail): string;
+export interface FleetLeaseUnavailableDetail {
+    code: typeof FLEET_LEASE_UNAVAILABLE;
+    reason?: string;
+    retryAfterSec?: number;
+}
+export declare function fleetLeaseUnavailableFromError(err: unknown): FleetLeaseUnavailableDetail | null;
+export declare function fleetLeaseUnavailableContent(detail: FleetLeaseUnavailableDetail): string;
 export type DenyAttributionRefusalKind = 'not_in_proof' | 'decision_conflict' | 'attribution_rejected';
 export interface DenyAttributionRefusalDetail {
     kind: DenyAttributionRefusalKind;
@@ -33,3 +41,33 @@ export interface SessionDeleteConflictDetail {
 }
 export declare function sessionDeleteConflictFromError(err: unknown): SessionDeleteConflictDetail | null;
 export declare function sessionDeleteConflictContent(detail: Pick<SessionDeleteConflictDetail, 'kind' | 'remaining' | 'activeTaskId'>): string;
+export type SettingsPermissionBucket = 'allow' | 'deny' | 'ask';
+export type SettingsPermissionBucketRefusalReason = 'over_cap' | 'bad_entry';
+export interface SettingsPermissionBucketRefusalDetail {
+    readonly bucket: SettingsPermissionBucket;
+    readonly reason: SettingsPermissionBucketRefusalReason;
+    readonly count?: number;
+    readonly cap?: number;
+    readonly index?: number;
+    readonly folded?: true;
+}
+export declare function settingsPermissionBucketRefusalFromError(err: unknown): SettingsPermissionBucketRefusalDetail | null;
+export declare function settingsPermissionBucketRefusalContent(detail: SettingsPermissionBucketRefusalDetail): string;
+export interface ToolDeclarationRefusalDetail {
+    readonly code: string;
+}
+export declare function toolDeclarationRefusalFromError(err: unknown): ToolDeclarationRefusalDetail | null;
+export declare function toolDeclarationRefusalContent(_detail: Pick<ToolDeclarationRefusalDetail, 'code'>): string;
+export interface BodyShapeRefusalDetail {
+    readonly unknownKeys?: readonly string[];
+    readonly unsupportedKeys?: readonly string[];
+}
+export declare function bodyShapeRefusalFromError(err: unknown): BodyShapeRefusalDetail | null;
+export declare function bodyShapeRefusalTouchesSettings(detail: BodyShapeRefusalDetail | null | undefined, sentBody?: TaskRequestLike): boolean | undefined;
+export interface HostPostureRefusalDetail {
+    readonly code: string;
+    readonly askedWholeEnvironment?: true;
+    readonly askedOpenWriteFace?: true;
+}
+export declare function hostPostureRefusalFromError(err: unknown, sentRequest?: TaskRequestLike): HostPostureRefusalDetail | null;
+export declare function hostPostureRefusalContent(detail: Pick<HostPostureRefusalDetail, 'askedWholeEnvironment' | 'askedOpenWriteFace'>): string;