@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/userInvokedSkillsCapability.js

@@ -1,6 +1,7 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
-import { ownDataField } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectUserInvokedSkillsCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -30,17 +31,40 @@ export function userInvokedSkillsAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function userInvokedSkillsDoctorDetail(reading) {
+export function userInvokedSkillsDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.userInvokedSkills');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('user-invoked skills');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         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)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'userInvokedSkills' }), lang);
         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)';
+            return renderMessage(msg('notice.capability.userInvokedSkills.notReported'), lang);
         case 'absent':
-            return 'user-invoked skills off on this deployment — naming skills on a request is not accepted';
+            return renderMessage(msg('notice.capability.userInvokedSkills.absent'), lang);
         case 'present':
-            return 'user-invoked skills on — skills the user names on a request take effect when the run starts';
+            return renderMessage(msg('notice.capability.userInvokedSkills.present'), lang);
     }
 }
+export function userInvokedSkillsDeclaration(names, reading) {
+    let named = false;
+    try {
+        named = Array.isArray(names) && names.length > 0;
+    }
+    catch {
+        named = false;
+    }
+    if (!named)
+        return { field: {} };
+    let kind;
+    try {
+        kind = reading !== null && typeof reading === 'object' ? readOwnDataValue(reading, 'kind') : undefined;
+    }
+    catch {
+        kind = undefined;
+    }
+    if (kind === 'present')
+        return { field: { userInvokedSkills: names } };
+    const cause = kind === 'absent' || kind === 'not_reported' || kind === 'unobserved' ? kind : 'unreadable';
+    return { field: {}, withheld: { cause } };
+}

package/dist/wireErrorTriage.d.ts

@@ -21,6 +21,13 @@ export declare function classifyTurnWireError(err: unknown): TurnWireErrorVerdic
 export declare function isWireTransportError(err: unknown): boolean;
 export declare function isPreStreamDrainingReject(err: unknown): boolean;
 export declare function effectiveWireErrorCode(err: unknown): string | undefined;
+export type NotFoundFailure = {
+    readonly kind: 'not_found';
+    readonly code: string;
+} | {
+    readonly kind: 'unknown_404';
+};
+export declare function isNotFoundFailure(e: {} | null | undefined): NotFoundFailure | false;
 export declare function corruptStoredRowWhere(err: unknown): string | undefined;
 export declare function corruptStoredRowContent(where: string): string;
 export declare function isResumeAtRejection(err: unknown): boolean;

package/dist/wireErrorTriage.js

@@ -1,4 +1,4 @@
-import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, protocolErrorNameOf, readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, readThrownStatusSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
@@ -76,6 +76,28 @@ export function effectiveWireErrorCode(err) {
     const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
     return foldedWireErrorCode(err, outer);
 }
+export function isNotFoundFailure(e) {
+    try {
+        if (e === null || e === undefined || (typeof e !== 'object' && typeof e !== 'function'))
+            return false;
+        const code = readThrownSlot(e, 'errorCode', 'data');
+        if (code === THROWN_SLOT_UNREADABLE)
+            return false;
+        if (typeof code === 'string') {
+            return code.startsWith(NOT_FOUND_CODE_PREFIX) ? Object.freeze({ kind: 'not_found', code }) : false;
+        }
+        const status = readThrownStatusSlot(e);
+        if (status === 404)
+            return Object.freeze({ kind: 'unknown_404' });
+        if (status === undefined && typeof e === 'object' && protocolErrorNameOf(e) === PROTOCOL_ERROR_NAME.NotFoundError)
+            return Object.freeze({ kind: 'unknown_404' });
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+const NOT_FOUND_CODE_PREFIX = 'not_found.';
 function foldedWireErrorCode(err, outer) {
     if (outer !== RESUME_POLICY_FOLD_CODE)
         return outer;

package/dist/wireFailureShape.js

@@ -1,3 +1,4 @@
+import { msg, renderMessage } from './i18n/translate.js';
 import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
 export function readThrownSlot(o, key, own = false) {
@@ -373,7 +374,7 @@ export function withAssemblyRefusal(err, cause) {
 export function asAssemblyRefusal(thrown, cause, who) {
     if (assemblyRefusalOf(thrown) !== undefined)
         return thrown;
-    return withAssemblyRefusal(new Error(`${who}: 装配时出错,拒绝装配(原抛出物见 cause)。`, { cause: thrown }), cause);
+    return withAssemblyRefusal(new Error(renderMessage(msg('config.assembly.thrownDuringAssembly', { who })), { cause: thrown }), cause);
 }
 export function assemblyRefusalOf(x) {
     if (x === null || x === undefined)

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } 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";
@@ -98,3 +98,15 @@ export interface AutonomyLaneRefusalDetail {
 }
 export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
 export declare function autonomyLaneRefusalContent(): string;
+export interface UserAttachmentRefusalDetail {
+    readonly code: typeof USER_ATTACHMENT_INVALID_ERROR_CODE;
+    readonly retryable: false;
+}
+export declare function userAttachmentRefusalFromError(err: {} | null | undefined): UserAttachmentRefusalDetail | null;
+export declare function userAttachmentRefusalContent(): string;
+export interface UserInvokedSkillRefusalDetail {
+    readonly code: typeof USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE;
+    readonly retryable: false;
+}
+export declare function userInvokedSkillRefusalFromError(err: {} | null | undefined): UserInvokedSkillRefusalDetail | null;
+export declare function userInvokedSkillRefusalContent(): string;

package/dist/wireRefusalCopy.js

@@ -1,9 +1,10 @@
 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 } from './engineErrorCodes.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 ownNonEmptyStringSlot(o, key) {
@@ -138,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';
@@ -526,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 ||
@@ -615,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';
 } | {
@@ -12,4 +13,4 @@ export type WorkflowsJournalReading = {
 export declare function projectWorkflowsJournalCapability(caps: unknown): WorkflowsJournalReading | undefined;
 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 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 {
@@ -30,17 +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);
     }
 }