@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/wireRefusalCopy.js

@@ -1,36 +1,25 @@
-import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField } from './wireFailureShape.js';
-import { readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
+import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const CONFLICT_APPROVAL_SETTLED = 'conflict.approval_settled';
 export const CONFLICT_RUN_NOT_RUNNING = 'conflict.run_not_running';
-function readStringField(o, key) {
-    const v = o[key];
+function ownNonEmptyStringSlot(o, key) {
+    const v = readThrownSlot(o, key, 'data');
     return typeof v === 'string' && v !== '' ? v : undefined;
 }
 export function cancelConflictFromError(err) {
-    let o;
-    try {
-        if (err === null || typeof err !== 'object')
-            return null;
-        o = err;
-        const rawStatus = o.status ?? o.statusCode;
-        const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
-        if (!is409)
-            return null;
-    }
-    catch {
+    if (err === null || typeof err !== 'object')
         return null;
-    }
-    let code;
-    try {
-        code = readStringField(o, 'errorCode');
-    }
-    catch {
-        code = undefined;
-    }
+    const rawStatus = readThrownStatusSlot(err);
+    if (rawStatus === THROWN_SLOT_UNREADABLE)
+        return null;
+    if (!(rawStatus === 409 || (rawStatus === undefined && protocolErrorNameOf(err) === PROTOCOL_ERROR_NAME.ConflictError)))
+        return null;
+    const code = ownNonEmptyStringSlot(err, 'errorCode');
     if (code === CONFLICT_APPROVAL_SETTLED)
         return { kind: 'approval_settled', code };
     if (code === CONFLICT_RUN_NOT_RUNNING)
@@ -58,17 +47,20 @@ export function usageWindowExhaustedFromError(err) {
         if (err === null || typeof err !== 'object')
             return null;
         const o = err;
-        if (o.errorCode !== USAGE_WINDOW_EXHAUSTED)
+        if (readThrownSlot(o, 'errorCode', 'data') !== USAGE_WINDOW_EXHAUSTED)
+            return null;
+        const rawStatus = readThrownStatusSlot(o);
+        if (rawStatus === THROWN_SLOT_UNREADABLE)
             return null;
-        const rawStatus = o.status ?? o.statusCode;
-        const is429 = rawStatus === 429 || (rawStatus === undefined && (o.name === 'UsageWindowExhaustedError' || o.name === 'RateLimitedError'));
+        const protocolName = rawStatus === undefined ? protocolErrorNameOf(o) : undefined;
+        const is429 = rawStatus === 429 || (rawStatus === undefined && (protocolName === PROTOCOL_ERROR_NAME.UsageWindowExhaustedError || protocolName === PROTOCOL_ERROR_NAME.RateLimitedError));
         if (!is429)
             return null;
         const rawSec = readErrorNumber(o, 'retryAfterSec');
         const sec = nonNegativeFinite(rawSec)
             ? Math.ceil(rawSec)
             : (() => {
-                const rawMs = o.retryAfterMs;
+                const rawMs = readThrownSlot(o, 'retryAfterMs', 'data');
                 return nonNegativeFinite(rawMs) ? Math.ceil(rawMs / 1000) : undefined;
             })();
         return { code: USAGE_WINDOW_EXHAUSTED, ...(sec !== undefined ? { retryAfterSec: sec } : {}) };
@@ -98,13 +90,7 @@ const positiveFinite = (v) => typeof v === 'number' && Number.isFinite(v) && v >
 export function fleetLeaseUnavailableFromError(err) {
     if (err === null || typeof err !== 'object')
         return null;
-    let code;
-    try {
-        code = err.errorCode;
-    }
-    catch {
-        return null;
-    }
+    const code = readThrownSlot(err, 'errorCode', 'data');
     if (code !== FLEET_LEASE_UNAVAILABLE)
         return null;
     const reason = readErrorString(err, 'reason');
@@ -153,33 +139,14 @@ export function fleetLeaseUnavailableContent(detail) {
     return `${head}${cause}${wait}`;
 }
 export function scenarioAssignmentUnknownFromError(err) {
-    try {
-        if (err === null || typeof err !== 'object')
-            return null;
-        if (effectiveWireErrorCode(err) !== SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE)
-            return null;
-        const detail = readErrorRecord(err, 'detail');
-        const bit = (key) => {
-            if (detail === undefined)
-                return undefined;
-            try {
-                return Object.hasOwn(detail, key) ? detail[key] : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const scenario = bit('scenario');
-        const source = bit('source');
-        return {
-            code: SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
-            ...(typeof scenario === 'string' && scenario.length > 0 ? { scenario } : {}),
-            ...(source === 'ruling' || source === 'deployment' ? { source } : {}),
-        };
-    }
-    catch {
+    const r = scenarioRefusalFromError(err);
+    if (r === null)
         return null;
-    }
+    return {
+        code: SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
+        ...(r.scenario !== undefined ? { scenario: r.scenario } : {}),
+        ...(r.source !== undefined ? { source: r.source } : {}),
+    };
 }
 const SETTLED_BY_NOT_IN_PROOF = 'settled_by_not_in_proof';
 const DECIDED_BY_NOT_IN_PROOF = 'decided_by_not_in_proof';
@@ -190,11 +157,11 @@ export function denyAttributionRefusalFromError(err, sentAttributionKey) {
         if (err === null || typeof err !== 'object')
             return null;
         const o = err;
-        const rawStatus = o.status ?? o.statusCode;
+        const rawStatus = readThrownStatusSlot(o);
         const status = typeof rawStatus === 'number' && Number.isFinite(rawStatus) ? rawStatus : undefined;
         if (status === undefined)
             return null;
-        const code = readStringField(o, 'errorCode');
+        const code = ownNonEmptyStringSlot(o, 'errorCode');
         if (code === undefined)
             return null;
         if (status === 400 && (code === SETTLED_BY_NOT_IN_PROOF || code === DECIDED_BY_NOT_IN_PROOF))
@@ -245,12 +212,12 @@ export function sessionDeleteConflictFromError(err) {
     try {
         if (err === null || typeof err !== 'object')
             return null;
-        const o = err;
-        const rawStatus = o.status ?? o.statusCode;
-        const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
-        if (!is409)
+        const rawStatus = readThrownStatusSlot(err);
+        if (rawStatus === THROWN_SLOT_UNREADABLE)
+            return null;
+        if (!(rawStatus === 409 || (rawStatus === undefined && protocolErrorNameOf(err) === PROTOCOL_ERROR_NAME.ConflictError)))
             return null;
-        const code = readStringField(o, 'errorCode');
+        const code = ownNonEmptyStringSlot(err, 'errorCode');
         if (code === CONFLICT_SESSION_CHILDREN_ALIVE) {
             const remaining = readErrorStringList(err, 'remaining')?.filter((id) => id.length > 0);
             return { kind: 'children_alive', code, ...(remaining !== undefined && remaining.length > 0 ? { remaining: Object.freeze(remaining) } : {}) };
@@ -391,13 +358,7 @@ export function toolDeclarationRefusalFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
             return null;
-        let code;
-        try {
-            code = err.errorCode;
-        }
-        catch {
-            return null;
-        }
+        const code = readThrownSlot(err, 'errorCode', 'data');
         if (typeof code !== 'string' || !CORE_TOOL_DECLARATION_CODES.includes(code))
             return null;
         return Object.freeze({ code });
@@ -547,7 +508,7 @@ function readProp(o, key) {
 }
 export function hostPostureRefusalFromError(err, sentRequest) {
     try {
-        if (readProp(err, 'errorCode') !== HOST_POSTURE_REFUSED)
+        if (readThrownSlot(err, 'errorCode', 'data') !== HOST_POSTURE_REFUSED)
             return null;
         const askedWholeEnvironment = readProp(sentRequest, 'inheritEnv') === 'all';
         const askedOpenWriteFace = readProp(sentRequest, 'permissionMode') === BYPASS_PERMISSIONS ||
@@ -600,11 +561,30 @@ export function hookMatcherRefusalFromError(err) {
         if (detail === undefined)
             return undefined;
         const event = readOwnNonEmptyString(detail, 'event');
-        const alias = readOwnNonEmptyString(detail, 'alias');
-        const canonical = readOwnNonEmptyString(detail, 'canonical');
-        if (event === undefined || alias === undefined || canonical === undefined)
+        if (event === undefined)
+            return undefined;
+        const reasonRaw = readOwnDataValue(detail, 'reason');
+        if (reasonRaw === undefined || reasonRaw === 'dead_alias') {
+            const alias = readOwnNonEmptyString(detail, 'alias');
+            const canonical = readOwnNonEmptyString(detail, 'canonical');
+            if (alias === undefined || canonical === undefined)
+                return undefined;
+            return Object.freeze({ reason: 'alias_without_canonical', event, alias, canonical });
+        }
+        if (reasonRaw !== 'invalid_regex' && reasonRaw !== 'over_budget')
+            return undefined;
+        const groupIndex = readOwnDataValue(detail, 'groupIndex');
+        if (typeof groupIndex !== 'number' || !Number.isInteger(groupIndex) || groupIndex < 0)
             return undefined;
-        return Object.freeze({ event, alias, canonical });
+        if (reasonRaw === 'invalid_regex')
+            return Object.freeze({ reason: 'invalid_regex', event, groupIndex });
+        const budget = readOwnDataValue(detail, 'budgetMs');
+        return Object.freeze({
+            reason: 'over_budget',
+            event,
+            groupIndex,
+            ...(typeof budget === 'number' && Number.isFinite(budget) && budget > 0 ? { budgetMs: budget } : {}),
+        });
     }
     catch {
         return undefined;
@@ -617,3 +597,17 @@ export function autonomyLaneRefusalContent() {
     return ('The engine did not start this leader run: this deployment runs in plan-only autonomy, and a leader run has no way to have its plan reviewed, ' +
         'so nothing was started · Submit the work as a regular run instead, or ask whoever operates the engine to change its autonomy setting');
 }
+export function userAttachmentRefusalFromError(err) {
+    return effectiveWireErrorCode(err) === USER_ATTACHMENT_INVALID_ERROR_CODE ? { code: USER_ATTACHMENT_INVALID_ERROR_CODE, retryable: false } : null;
+}
+export function userAttachmentRefusalContent() {
+    return ('This message was not sent: the engine refused the files attached to it — together with the message they are more than it can take in one request on this model, ' +
+        'or one of them is in a form it does not accept · Nothing was started and your draft is kept · Remove some attachments or attach smaller parts, then send it again');
+}
+export function userInvokedSkillRefusalFromError(err) {
+    return effectiveWireErrorCode(err) === USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE ? { code: USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, retryable: false } : null;
+}
+export function userInvokedSkillRefusalContent() {
+    return ('The engine did not start this run: a skill named for it is not one this run has loaded, or skills are turned off for this run · ' +
+        'Nothing was started and your draft is kept · Check the skill name, or load that skill, then send it again');
+}

package/dist/workflowsJournalCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type WorkflowsJournalReading = {
     kind: 'unobserved';
 } | {
@@ -10,10 +11,6 @@ export type WorkflowsJournalReading = {
     kind: 'present';
 };
 export declare function projectWorkflowsJournalCapability(caps: unknown): WorkflowsJournalReading | undefined;
-export declare function noteEngineCapsForWorkflowsJournal(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedWorkflowsJournal(baseUrl?: string | undefined): WorkflowsJournalReading;
 export declare function workflowsJournalAvailable(reading: WorkflowsJournalReading): 'yes' | 'no' | 'unknown';
-export declare function workflowsJournalDoctorDetail(reading: WorkflowsJournalReading): string;
-export declare function __resetWorkflowsJournalReadingsForTests(): void;
+export declare function workflowsJournalDoctorDetail(reading: WorkflowsJournalReading, lang?: UiLanguage): string;

package/dist/workflowsJournalCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectWorkflowsJournalCapability(caps) {
     try {
@@ -20,9 +21,6 @@ const reader = createEngineCapReader({
     name: 'workflowsJournal',
     project: projectWorkflowsJournalCapability,
 });
-export function noteEngineCapsForWorkflowsJournal(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedWorkflowsJournal(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -33,20 +31,18 @@ export function workflowsJournalAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function workflowsJournalDoctorDetail(reading) {
+export function workflowsJournalDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.workflowsJournal');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('workflow journal');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         case 'unobserved':
-            return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); 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)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'workflowsJournal' }), lang);
         case 'not_reported':
-            return 'workflow journal not reported by this engine — the engine predates the separate flag, so the workflow listing flag still covers the journal';
+            return renderMessage(msg('notice.capability.workflowsJournal.notReported'), lang);
         case 'absent':
-            return 'no workflow journal on this deployment — workflows can be listed and followed, but their execution journal cannot be read';
+            return renderMessage(msg('notice.capability.workflowsJournal.absent'), lang);
         case 'present':
-            return 'workflow journal on — a workflow’s execution journal can be read';
+            return renderMessage(msg('notice.capability.workflowsJournal.present'), lang);
     }
 }
-export function __resetWorkflowsJournalReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/writeProtectionCapability.d.ts

@@ -24,10 +24,6 @@ export interface WriteProtectionPostureView {
     droppedDefaultRows?: readonly string[];
 }
 export declare function projectWriteProtectionPosture(wiring: unknown): WriteProtectionPostureView | undefined;
-export declare function noteEngineCapsForWriteProtection(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedWriteProtection(baseUrl?: string | undefined): WriteProtectionReading;
 export declare function writeProtectionDoctorDetail(reading: WriteProtectionReading): string;
 export declare function writeProtectionPostureDetail(posture: WriteProtectionPostureView): string;
-export declare function __resetWriteProtectionReadingsForTests(): void;

package/dist/writeProtectionCapability.js

@@ -66,9 +66,6 @@ const reader = createEngineCapReader({
     name: 'writeProtection',
     project: projectWriteProtectionCapability,
 });
-export function noteEngineCapsForWriteProtection(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedWriteProtection(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -113,6 +110,3 @@ export function writeProtectionPostureDetail(posture) {
         : '';
     return `source ${source} · ${String(posture.rows.length)} ${posture.rows.length === 1 ? 'name' : 'names'}: ${shown}${more}${dropped}`;
 }
-export function __resetWriteProtectionReadingsForTests() {
-    reader.__resetForTests();
-}