@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/userAttachmentEnvelope.d.ts

@@ -1,6 +1,6 @@
 import { type DescriptorView } from './humanTurnRead.js';
 export type UserAttachmentSource = 'at-mention' | 'compact-restore';
-export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied' | 'approval-required' | 'server-not-connected' | 'resource-not-listed' | 'read-failed';
+export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied' | 'approval-required' | 'server-not-connected' | 'resource-not-listed' | 'read-failed' | 'tools-elsewhere' | 'tools-location-unconfirmed';
 export type UserAttachmentMcpResourcePart = {
     readonly kind: 'text';
     readonly text: string;
@@ -77,6 +77,7 @@ export type UserAttachmentDescriptor = {
     readonly truncated: boolean;
 };
 export declare function showAttachmentName(s: string): string;
+export declare function showAttachmentNameCc(s: string): string;
 export declare function mintEnvelopeOf(d: DescriptorView, imageDelivery: 'attached' | 'not-attached'): string;
 export declare function seatTextOf(d: DescriptorView): string | undefined;
 export declare function mintReferenceOf(d: DescriptorView): string;

package/dist/userAttachmentEnvelope.js

@@ -1,4 +1,5 @@
 import { readDescriptor } from './humanTurnRead.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const TILDE_CLASS_RUN = /[~\u02DC\u2053\u223C\u301C\uFF5E]+/g;
 function envelopeFence(text) {
     let longest = 0;
@@ -29,6 +30,13 @@ export function showAttachmentName(s) {
         return cp > 0xffff ? `\\u{${cp.toString(16)}}` : `\\u${hex4(cp)}`;
     });
 }
+const CC_CONTROL_UNITS = /[\p{Cc}\u2028\u2029]/gu;
+export function showAttachmentNameCc(s) {
+    return String(s ?? '')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replace(CC_CONTROL_UNITS, (c) => `&#${c.charCodeAt(0)};`);
+}
 const ESCAPE_NOTE = 'Some lines contain line-break control characters inside the line; they are shown as escape sequences (such as \\r or \\u2028), so those lines are not byte-for-byte the same as the file.';
 const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
 function firstLine(source, what, name) {
@@ -169,6 +177,8 @@ const NOT_INCLUDED_REASON = Object.freeze({
     'server-not-connected': 'the MCP server it comes from is not connected',
     'resource-not-listed': 'the MCP server does not list that resource',
     'read-failed': 'reading it from the MCP server failed',
+    'tools-elsewhere': renderMessage(msg('attachments.withheld.toolsElsewhere.model')),
+    'tools-location-unconfirmed': renderMessage(msg('attachments.withheld.toolsLocationUnconfirmed.model')),
 });
 function targetWhat(target) {
     return target === 'directory' ? 'a directory' : target === 'file' ? 'a file' : 'a file or directory';

package/dist/wireErrorTriage.js

@@ -2,6 +2,7 @@ import { PROTOCOL_ERROR_NAME, effectiveWireCodeReading, isSlotCarrier, protocolE
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
+import { isStreamEndedWithoutTerminalError } from './sseIdleTriage.js';
 import { answerReadingOf, captureAnswer, captureUnanswered, causeSlotReadOf, effectiveCodeOf, noteTriageReading, ownReadingSlot } from './engineWireFor.js';
 import { CORRUPT_ROW_ERROR_CODE, DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, 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|\bterminated\b|\bother side closed\b/i;
@@ -105,7 +106,7 @@ export function classifyTurnWireError(err) {
     if (captured !== undefined && captured.layer === err)
         return httpVerdictOf(captured, () => renderedText(err), undefined, topCauseRecordOf(err, topCauseRead));
     const slots = readTurnErrorSlots(err, topStatusOf(err, ans), topCauseRead);
-    if (slots.status !== THROWN_SLOT_UNREADABLE && slots.name === 'StreamEndedWithoutTerminalError') {
+    if (slots.status !== THROWN_SLOT_UNREADABLE && isStreamEndedWithoutTerminalError(err)) {
         return noted({ kind: 'stream-ended-without-terminal' }, ans, captured, transportShapeOf(slots, err, ans), err, slots.errorCode, topCauseRead);
     }
     if (captured !== undefined) {

package/dist/wireFailureShape.d.ts

@@ -13,6 +13,8 @@ interface WireFailureShape {
 export declare const THROWN_SLOT_UNREADABLE: unique symbol;
 export declare function isSlotCarrier(x: {} | null | undefined): x is object;
 export declare function readThrownSlot(o: unknown, key: string, own?: boolean | 'data'): unknown;
+export declare function errnoCode(e: {} | null | undefined): string | undefined;
+export declare function thrownSlotOf(err: {} | null | undefined, name: string, kind?: boolean | 'data'): {} | null | undefined;
 export declare function thrownIsInstanceOf<C extends abstract new (...args: never[]) => unknown>(e: unknown, cls: C): e is InstanceType<C>;
 export type ThrownExtraReading = {
     readonly state: 'object';
@@ -24,14 +26,16 @@ export type ThrownExtraReading = {
 };
 export declare function readThrownExtra(o: {} | null | undefined): ThrownExtraReading;
 export interface ThrownExtraSnapshot {
-    readonly sdkInstance: boolean;
     readonly bag: ThrownExtraReading;
 }
 export declare function readThrownExtraSnapshot(o: {} | null | undefined): ThrownExtraSnapshot;
+export declare function liftLegacyRefusalFacts(code: {} | null | undefined, bag: object): object;
+export declare function placeThrownExtraOnCopy<V>(thrown: object, copy: object, copyBag: (bag: object) => V | undefined): 'placed' | 'not_placed' | 'place_failed';
 export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly ApprovalBindingMismatchError: "ApprovalBindingMismatchError";
     readonly ApprovalStaleError: "ApprovalStaleError";
     readonly AskDecidedError: "AskDecidedError";
+    readonly CheckpointInvalidOutcomeError: "CheckpointInvalidOutcomeError";
     readonly ConflictError: "ConflictError";
     readonly NotFoundError: "NotFoundError";
     readonly ParkedResumeStartupError: "ParkedResumeStartupError";
@@ -47,18 +51,15 @@ export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly UsageWindowExhaustedError: "UsageWindowExhaustedError";
 }>;
 export type ProtocolErrorName = (typeof PROTOCOL_ERROR_NAME)[keyof typeof PROTOCOL_ERROR_NAME];
-export declare function isSdkErrorInstance(o: object): boolean;
 export type ProtocolErrorNameReading = {
     readonly state: 'named';
     readonly name: ProtocolErrorName;
 } | {
     readonly state: 'absent';
-} | {
-    readonly state: 'sdk-instance';
 } | {
     readonly state: 'unreadable';
 };
-export declare function protocolErrorNameReading(e: object, extra?: ThrownExtraSnapshot): ProtocolErrorNameReading;
+export declare function protocolErrorNameReading(e: object): ProtocolErrorNameReading;
 export declare function protocolErrorNameOf(e: object): ProtocolErrorName | undefined;
 export type ThrownStatusReading = number | undefined | typeof THROWN_SLOT_UNREADABLE;
 export declare function readThrownStatusSlot(o: object, notePresence?: (presence: SlotPresence) => void): ThrownStatusReading;

package/dist/wireFailureShape.js

@@ -1,6 +1,7 @@
 import { msg, renderMessage } from './i18n/translate.js';
-import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
-import { RESUME_POLICY_FOLD_CODE } from './engineErrorCodes.js';
+import { guardedRead, ownDataField, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_TOOL_FACE_CONTROL, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USER_ATTACHMENT_INVALID_ERROR_CODE } from './engineErrorCodes.js';
+import { requestCoordinateText } from './requestCoordinate.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
 export function isSlotCarrier(x) {
     return (typeof x === 'object' && x !== null) || typeof x === 'function';
@@ -20,6 +21,13 @@ export function readThrownSlot(o, key, own = false) {
         return THROWN_SLOT_UNREADABLE;
     }
 }
+export function errnoCode(e) {
+    return guardedRead(() => readOwnDataNonEmptyString(e, 'code'));
+}
+export function thrownSlotOf(err, name, kind = false) {
+    const v = readThrownSlot(err, name, kind);
+    return v === THROWN_SLOT_UNREADABLE ? undefined : v;
+}
 function readGuarded(o, key) {
     const v = readThrownSlot(o, key);
     return v === THROWN_SLOT_UNREADABLE ? undefined : v;
@@ -91,39 +99,157 @@ export function readThrownExtra(o) {
 }
 export function readThrownExtraSnapshot(o) {
     if (o === null || o === undefined || (typeof o !== 'object' && typeof o !== 'function'))
-        return { sdkInstance: false, bag: { state: 'absent' } };
+        return { bag: { state: 'absent' } };
     let at;
     try {
         at = extraSlotOf(o);
     }
     catch {
-        return { sdkInstance: false, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     }
-    const sdkInstance = at.kind === 'sdk-class';
     if (at.kind === 'own-accessor')
-        return { sdkInstance, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     if (at.kind === 'none')
-        return { sdkInstance, bag: { state: 'absent' } };
+        return { bag: { state: 'absent' } };
     let slot;
     try {
         slot = at.kind === 'own-data' ? at.value : Reflect.get(o, EXTRA_KEY);
     }
     catch {
-        return { sdkInstance, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     }
     try {
         if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
-            return { sdkInstance, bag: { state: 'absent' } };
+            return { bag: { state: 'absent' } };
+    }
+    catch {
+        return { bag: { state: 'unreadable' } };
+    }
+    return { bag: { state: 'object', value: liftLegacyRefusalFacts(readThrownSlot(o, 'errorCode', 'data'), slot) } };
+}
+export function liftLegacyRefusalFacts(code, bag) {
+    try {
+        if (typeof code !== 'string')
+            return bag;
+        const dd = Object.getOwnPropertyDescriptor(bag, 'detail');
+        if (dd === undefined || !Object.hasOwn(dd, 'value'))
+            return bag;
+        const detail = dd.value;
+        if (typeof detail !== 'object' || detail === null || Array.isArray(detail))
+            return bag;
+        const moves = legacyRefusalMovesOf(code, bag, detail);
+        if (moves === undefined)
+            return bag;
+        const out = Object.create(null);
+        for (const key of Reflect.ownKeys(bag)) {
+            if (key === 'detail')
+                continue;
+            const d = Object.getOwnPropertyDescriptor(bag, key);
+            if (d !== undefined)
+                Object.defineProperty(out, key, { ...d, configurable: true });
+        }
+        for (const [key, value, override] of moves) {
+            if (!override && Object.getOwnPropertyDescriptor(out, key) !== undefined)
+                continue;
+            Object.defineProperty(out, key, { value, enumerable: true, writable: false, configurable: true });
+        }
+        return Object.freeze(out);
     }
     catch {
-        return { sdkInstance, bag: { state: 'unreadable' } };
+        return bag;
+    }
+}
+const LEGACY_PROBLEMS_CODES = Object.freeze(['request.field_invalid', CONFIG_AGENT_UNKNOWN_TOOL, CONFIG_TOOL_FACE_CONTROL, 'request.unprocessable', RESUME_POLICY_FOLD_CODE]);
+const LEGACY_HOOKS_KEYS = Object.freeze(['reason', 'event', 'alias', 'canonical', 'groupIndex', 'budgetMs', 'totalMs', 'type', 'key', 'count', 'cap']);
+function legacyRefusalMovesOf(code, bag, detail) {
+    const moves = [];
+    const take = (from, to = from, override = false) => {
+        const v = guardedRead(() => readOwnDataValue(detail, from));
+        if (v !== undefined)
+            moves.push([to, v, override]);
+    };
+    const rootField = guardedRead(() => readOwnDataValue(bag, 'field'));
+    if (code === 'request.field_invalid' && rootField === 'settings.hooks') {
+        for (const k of LEGACY_HOOKS_KEYS)
+            take(k);
+        const path = legacyHooksPathOf(detail);
+        if (path !== undefined)
+            moves.push(['field', requestCoordinateText(path[0] === 'hooks' ? 'settings' : 'settings.hooks', path), true]);
+        for (const k of ['problems', 'total', 'callerTrust'])
+            take(k);
+        return moves;
+    }
+    if (code === REQUEST_FIELD_CONFLICT) {
+        take('kind', 'reason');
+        for (const k of ['fields', 'count', 'cap'])
+            take(k);
+        return moves;
+    }
+    if (LEGACY_PROBLEMS_CODES.includes(code)) {
+        for (const k of ['problems', 'total', 'callerTrust'])
+            take(k);
+        return moves;
+    }
+    if (code === 'conflict.session_placed')
+        take('placement_kind');
+    else if (code === SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE)
+        for (const k of ['scenario', 'source'])
+            take(k);
+    else if (code === 'steering.duplicate_input_id')
+        take('differs');
+    else if (code === USER_ATTACHMENT_INVALID_ERROR_CODE) {
+        const path = guardedRead(() => readOwnDataValue(detail, 'path'));
+        if (typeof path === 'string' && path.length > 0)
+            moves.push(['field', path, false]);
+        const index = guardedRead(() => readOwnDataValue(detail, 'index'));
+        if (typeof index === 'number' && Number.isSafeInteger(index) && index >= 0)
+            moves.push(['index', index, false]);
+    }
+    else
+        return undefined;
+    return moves;
+}
+function legacyHooksPathOf(detail) {
+    try {
+        const raw = readOwnDataValue(detail, 'path');
+        if (!Array.isArray(raw) || raw.length === 0)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < raw.length; i++) {
+            if (!Object.hasOwn(raw, i))
+                return undefined;
+            const v = raw[i];
+            if (typeof v === 'string' || (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0))
+                out.push(v);
+            else
+                return undefined;
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function placeThrownExtraOnCopy(thrown, copy, copyBag) {
+    try {
+        const bag = readThrownExtraSnapshot(thrown).bag;
+        if (bag.state !== 'object')
+            return 'not_placed';
+        const value = copyBag(bag.value);
+        if (value === undefined)
+            return 'not_placed';
+        Object.defineProperty(copy, EXTRA_KEY, { value, writable: true, enumerable: true, configurable: true });
+        return 'placed';
+    }
+    catch {
+        return 'place_failed';
     }
-    return { sdkInstance, bag: { state: 'object', value: slot } };
 }
 export const PROTOCOL_ERROR_NAME = Object.freeze({
     ApprovalBindingMismatchError: 'ApprovalBindingMismatchError',
     ApprovalStaleError: 'ApprovalStaleError',
     AskDecidedError: 'AskDecidedError',
+    CheckpointInvalidOutcomeError: 'CheckpointInvalidOutcomeError',
     ConflictError: 'ConflictError',
     NotFoundError: 'NotFoundError',
     ParkedResumeStartupError: 'ParkedResumeStartupError',
@@ -139,20 +265,10 @@ export const PROTOCOL_ERROR_NAME = Object.freeze({
     UsageWindowExhaustedError: 'UsageWindowExhaustedError',
 });
 const PROTOCOL_ERROR_NAMES = new Set(Object.values(PROTOCOL_ERROR_NAME));
-export function isSdkErrorInstance(o) {
-    try {
-        return extraSlotOf(o).kind === 'sdk-class';
-    }
-    catch {
-        return false;
-    }
-}
-export function protocolErrorNameReading(e, extra) {
+export function protocolErrorNameReading(e) {
     if (typeof e !== 'object' || e === null)
         return { state: 'absent' };
     try {
-        if (extra !== undefined ? extra.sdkInstance : isSdkErrorInstance(e))
-            return { state: 'sdk-instance' };
         const name = ownDataField(e, 'name');
         return typeof name === 'string' && PROTOCOL_ERROR_NAMES.has(name) ? { state: 'named', name: name } : { state: 'absent' };
     }
@@ -482,24 +598,20 @@ export function readRefusalNamedFields(o) {
             out.push(v);
     };
     add(guardedRead(() => readRefusalField(o)));
-    const detail = guardedRead(() => readErrorRecord(o, 'detail'));
-    if (detail !== undefined) {
-        add(guardedRead(() => readOwnDataValue(detail, 'field')));
-        try {
-            const list = readOwnDataValue(detail, 'problems');
-            if (Array.isArray(list)) {
-                const n = list.length;
-                const len = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, REFUSAL_PROBLEMS_READ_MAX) : 0;
-                for (let i = 0; i < len; i += 1) {
-                    const item = guardedRead(() => readOwnDataValue(list, String(i)));
-                    if (typeof item !== 'object' || item === null)
-                        continue;
-                    add(guardedRead(() => readOwnDataValue(item, 'field')));
-                }
+    try {
+        const list = readErrorPresent(o, 'problems');
+        if (Array.isArray(list)) {
+            const n = list.length;
+            const len = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, REFUSAL_PROBLEMS_READ_MAX) : 0;
+            for (let i = 0; i < len; i += 1) {
+                const item = guardedRead(() => readOwnDataValue(list, String(i)));
+                if (typeof item !== 'object' || item === null)
+                    continue;
+                add(guardedRead(() => readOwnDataValue(item, 'field')));
             }
         }
-        catch {
-        }
+    }
+    catch {
     }
     return Object.freeze(out);
 }

package/dist/wireRefusalCopy.d.ts

@@ -53,6 +53,7 @@ export interface SessionDeleteConflictDetail {
 }
 export declare function sessionDeleteConflictFromError(err: unknown): SessionDeleteConflictDetail | null;
 export declare function sessionDeleteConflictContent(detail: Pick<SessionDeleteConflictDetail, 'kind' | 'remaining' | 'activeTaskId'>, lang?: UiLanguage): string;
+declare const FIELD_INVALID = "request.field_invalid";
 export type SettingsPermissionBucket = 'allow' | 'deny' | 'ask';
 export type SettingsPermissionBucketRefusalReason = 'over_cap' | 'bad_entry';
 export interface SettingsPermissionBucketRefusalDetail {
@@ -107,28 +108,29 @@ export type HookMatcherRefusal = {
     readonly event: string;
     readonly alias: string;
     readonly canonical: string;
-    readonly path?: readonly (string | number)[];
+    readonly groupIndex?: number;
+    readonly field?: string;
 } | {
     readonly reason: 'invalid_regex';
     readonly event: string;
     readonly groupIndex: number;
-    readonly path?: readonly (string | number)[];
+    readonly field?: string;
 } | {
     readonly reason: 'over_budget';
     readonly event: string;
     readonly groupIndex: number;
     readonly budgetMs?: number;
-    readonly path?: readonly (string | number)[];
+    readonly field?: string;
 } | {
     readonly reason: 'budget_exceeded';
     readonly event: string;
     readonly groupIndex: number;
     readonly totalMs?: number;
-    readonly path?: readonly (string | number)[];
+    readonly field?: string;
 };
 export interface SettingsHooksRefusal {
     readonly reason: string;
-    readonly path?: readonly (string | number)[];
+    readonly field: string;
     readonly matcher?: HookMatcherRefusal;
     readonly count?: number;
     readonly cap?: number;
@@ -158,6 +160,15 @@ export interface SessionIdRetiredDetail {
 }
 export declare function sessionIdRetiredFromError(err: {} | null | undefined): SessionIdRetiredDetail | null;
 export declare function sessionIdRetiredContent(detail: Pick<SessionIdRetiredDetail, 'folded'>, lang?: UiLanguage): string;
+export type UnreadRequestMembersFace = 'settings_hooks' | 'settings_env' | 'settings_other' | 'mcp_transport' | 'a2a_headers';
+export interface UnreadRequestMembersDetail {
+    readonly code: typeof FIELD_INVALID;
+    readonly field: string;
+    readonly face: UnreadRequestMembersFace;
+    readonly folded?: true;
+}
+export declare function unreadRequestMembersFromError(err: {} | null | undefined): UnreadRequestMembersDetail | null;
+export declare function unreadRequestMembersContent(detail: Pick<UnreadRequestMembersDetail, 'field' | 'face' | 'folded'>, lang?: UiLanguage): string;
 export interface RunConcurrencyCapDetail {
     readonly code: typeof LIMIT_RATE_EXCEEDED;
     readonly reason: typeof RATE_EXCEEDED_RUN_CONCURRENCY_CAP;