@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/subagentEditOutcomes.js

@@ -0,0 +1,43 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { readOwnDataValue } from './ownKey.js';
+const isPlainRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function countOf(v, key) {
+    const x = readOwnDataValue(v, key);
+    return typeof x === 'number' && Number.isSafeInteger(x) && x >= 0 ? x : undefined;
+}
+function checkedOutcomes(attempted, succeeded, refused, failed) {
+    if (attempted === undefined || succeeded === undefined || refused === undefined || failed === undefined)
+        return undefined;
+    if (succeeded + refused + failed > attempted)
+        return undefined;
+    return Object.freeze({ attempted, succeeded, refused, failed });
+}
+export function subagentEditOutcomesOf(toolStats) {
+    try {
+        if (!isPlainRecord(toolStats))
+            return undefined;
+        const outcomes = readOwnDataValue(toolStats, 'editFileOutcomes');
+        if (!isPlainRecord(outcomes))
+            return undefined;
+        return checkedOutcomes(countOf(toolStats, 'editFileCount'), countOf(outcomes, 'landed'), countOf(outcomes, 'refused'), countOf(outcomes, 'failed'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function subagentEditOutcomesSentence(outcomes, lang) {
+    try {
+        if (!isPlainRecord(outcomes))
+            return undefined;
+        const v = checkedOutcomes(countOf(outcomes, 'attempted'), countOf(outcomes, 'succeeded'), countOf(outcomes, 'refused'), countOf(outcomes, 'failed'));
+        if (v === undefined || v.attempted === 0)
+            return undefined;
+        if (v.succeeded === v.attempted) {
+            return renderMessage(msg(v.attempted === 1 ? 'session.subagent.editOutcomes.allApplied.one' : 'session.subagent.editOutcomes.allApplied.other', { count: v.attempted }), lang);
+        }
+        return renderMessage(msg('session.subagent.editOutcomes.mixed', { attempted: v.attempted, succeeded: v.succeeded, refused: v.refused, failed: v.failed }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/supportFloor.d.ts

@@ -1,8 +1,9 @@
-export type SupportFloorComponent = 'server' | 'core' | 'sdk';
+export type SupportFloorComponent = 'server' | 'core' | 'sdk' | 'settingsContract';
 export interface SupportFloor {
     readonly server: string;
     readonly core: string;
     readonly sdk: string;
+    readonly settingsContract: string;
 }
 export declare const SUPPORT_FLOOR: Readonly<SupportFloor>;
 export declare function supportFloorOf(component: unknown): string | undefined;

package/dist/supportFloor.js

@@ -1,7 +1,7 @@
 import { DECLARED_SUPPORT_FLOOR } from './declared/supportFloorDeclared.js';
 export const SUPPORT_FLOOR = DECLARED_SUPPORT_FLOOR;
 export function supportFloorOf(component) {
-    if (component === 'server' || component === 'core' || component === 'sdk')
+    if (component === 'server' || component === 'core' || component === 'sdk' || component === 'settingsContract')
         return SUPPORT_FLOOR[component];
     return undefined;
 }

package/dist/toolResult.js

@@ -11,11 +11,12 @@ import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 import { SEMA_REFUSAL_NOTED_KEY } from './engineRowRef.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 const LEGACY_STRUCTURED_DETAIL_TYPE = 'task-output';
+const LEGACY_FILE_UNCHANGED_DETAIL_TYPE = 'file_unchanged';
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)
         return undefined;
     const t = structured.type;
-    return typeof t === 'string' && (STRUCTURED_DETAIL_TYPES.has(t) || t === LEGACY_STRUCTURED_DETAIL_TYPE) ? t : undefined;
+    return typeof t === 'string' && (STRUCTURED_DETAIL_TYPES.has(t) || t === LEGACY_STRUCTURED_DETAIL_TYPE || t === LEGACY_FILE_UNCHANGED_DETAIL_TYPE) ? t : undefined;
 }
 const MAX_STRUCTURED_FIELD_CHARS = 1_000_000;
 export const PROTOCOL_MARKERS = {
@@ -1072,6 +1073,7 @@ export function readCompletedAgentCard(structured) {
         return null;
     const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
     const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+    const failureCode = Object.hasOwn(s, 'code') ? str(s.code) : str(s.errorCode);
     return {
         status,
         taskId,
@@ -1082,7 +1084,7 @@ export function readCompletedAgentCard(structured) {
         ...(s.structuredOutput !== undefined ? { structuredOutput: s.structuredOutput } : {}),
         ...(str(s.blockedReason) !== undefined ? { blockedReason: str(s.blockedReason) } : {}),
         ...(str(s.errorMessage) !== undefined ? { errorMessage: str(s.errorMessage) } : {}),
-        ...(str(s.errorCode) !== undefined ? { errorCode: str(s.errorCode) } : {}),
+        ...(failureCode !== undefined ? { errorCode: failureCode } : {}),
         ...(num(s.retryAfterMs) !== undefined ? { retryAfterMs: num(s.retryAfterMs) } : {}),
         ...(typeof s.degraded === 'object' && s.degraded !== null
             ? { degraded: s.degraded }

package/dist/toolRoster.d.ts

@@ -22,6 +22,7 @@ export interface ToolRosterEntryView {
         peer: string;
         declaredBy?: string;
     };
+    remoteName?: string;
     contract?: {
         contractId: string;
         implementationRevision?: string;

package/dist/toolRoster.js

@@ -50,6 +50,7 @@ function readEntry(raw) {
         ...(peer !== undefined
             ? { origin: { peer, ...(declaredBy !== undefined ? { declaredBy } : {}) } }
             : {}),
+        ...(str(o.remoteName) !== undefined ? { remoteName: str(o.remoteName) } : {}),
         ...(contractId !== undefined
             ? { contract: { contractId, ...(implementationRevision !== undefined ? { implementationRevision } : {}) } }
             : {}),

package/dist/usageAnalytics.js

@@ -1,4 +1,5 @@
 import { readThrownSlot, slotReadOf, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+import { ROUTE_NOT_FOUND } from './engineErrorCodes.js';
 export const USAGE_SENTENCES = Object.freeze({
     analyticsUnavailable: 'Usage analytics aren’t available on this backend.',
     analyticsUnread: 'Usage analytics couldn’t be read just now.',
@@ -22,7 +23,7 @@ export function classifyUsageFailure(e) {
             return { kind: 'unavailable', why: 'capability' };
         if (code.startsWith('feature.'))
             return { kind: 'unavailable', why: 'feature' };
-        if (code === 'not_found.route')
+        if (code === ROUTE_NOT_FOUND)
             return { kind: 'unavailable', why: 'route' };
         return { kind: 'failed', error: e };
     }

package/dist/userAttachmentEnvelope.d.ts

@@ -75,10 +75,21 @@ export type UserAttachmentDescriptor = {
     readonly name: string;
     readonly parts: readonly UserAttachmentMcpResourcePart[];
     readonly truncated: boolean;
+} | {
+    readonly kind: 'path';
+    readonly name: string;
+    readonly path: string;
+    readonly lines?: {
+        readonly start: number;
+        readonly end?: number;
+    };
 };
 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 mintPathPointerOf(d: Extract<DescriptorView, {
+    kind: 'path';
+}>): string;
 export declare function mintReferenceOf(d: DescriptorView): string;
 export declare function mintUserAttachmentEnvelope(descriptor: UserAttachmentDescriptor): string;

package/dist/userAttachmentEnvelope.js

@@ -280,6 +280,8 @@ function envelopeInner(d, imageDelivery) {
     }
 }
 export function mintEnvelopeOf(d, imageDelivery) {
+    if (d.kind === 'path')
+        return mintReferenceOf(d);
     return `${TAG_OPEN}${tagAttributes(d)}>\n${envelopeInner(d, imageDelivery)}\n${TAG_CLOSE}`;
 }
 function referenceSentence(d) {
@@ -288,8 +290,8 @@ function referenceSentence(d) {
         return `The user mentioned the MCP resource ${name} (${showAttachmentName(d.uri)} on the server ${showAttachmentName(d.server)}) in this message; its contents are not included here.`;
     }
     const path = showAttachmentName(d.path);
-    const what = d.kind === 'directory' ? 'directory' : d.kind === 'not-included' ? targetWhat(d.target).replace(/^an? /, '') : 'file';
-    if (d.kind !== 'directory' && d.kind !== 'not-included' && d.source === 'compact-restore') {
+    const what = d.kind === 'directory' ? 'directory' : d.kind === 'not-included' ? targetWhat(d.target).replace(/^an? /, '') : d.kind === 'path' ? targetWhat('path').replace(/^an? /, '') : 'file';
+    if (d.kind !== 'directory' && d.kind !== 'not-included' && d.kind !== 'path' && d.source === 'compact-restore') {
         return `The client re-attached the ${what} ${name} (${path}), read earlier in this conversation; its contents are not included here.`;
     }
     return `The user mentioned the ${what} ${name} (${path}) in this message; its contents are not included here.`;
@@ -321,6 +323,9 @@ export function seatTextOf(d) {
     }
     return text.length > 0 ? text : undefined;
 }
+export function mintPathPointerOf(d) {
+    return renderMessage(msg('attachments.pathPointer.model', { path: showAttachmentName(d.path) }));
+}
 export function mintReferenceOf(d) {
     return `${TAG_OPEN}${tagAttributes(d)} />\n${referenceSentence(d)}`;
 }

package/dist/userAttachmentSeat.d.ts

@@ -18,4 +18,10 @@ export type UserAttachmentSeatReading = {
 } | UserAttachmentSeatPresent;
 export declare function projectUserAttachmentSeatCapability(caps: {} | null | undefined): UserAttachmentSeatReading | undefined;
 export declare function observedUserAttachmentSeat(baseUrl?: string | undefined): UserAttachmentSeatReading;
-export declare function userAttachmentSeatAdmits(reading: UserAttachmentSeatReading | undefined): 'yes' | 'no' | 'unknown';
+interface UserAttachmentSeatUse {
+    readonly supply?: 'content_text' | 'path';
+    readonly scenario?: {} | null;
+    readonly lane?: 'objective' | 'steer';
+}
+export declare function userAttachmentSeatAdmits(reading: UserAttachmentSeatReading | undefined, use?: UserAttachmentSeatUse): 'yes' | 'no' | 'unknown';
+export {};

package/dist/userAttachmentSeat.js

@@ -49,7 +49,35 @@ const reader = createEngineCapReader({ name: 'userAttachments', project: project
 export function observedUserAttachmentSeat(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
-export function userAttachmentSeatAdmits(reading) {
+function scenarioSupplyReadingOf(card) {
+    if (card === undefined || card === null)
+        return 'not_handed';
+    try {
+        if (!isPlainRecord(card))
+            return 'unreadable';
+        const raw = ownDataField(card, 'attachmentSupplies');
+        if (raw === undefined)
+            return 'not_on_card';
+        return stringList(raw) ?? 'unreadable';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function seatQuestionOf(use) {
+    if (use === undefined)
+        return { supply: 'content_text', lane: 'objective', card: 'not_handed' };
+    if (!isPlainRecord(use))
+        return undefined;
+    const supply = ownDataField(use, 'supply');
+    const lane = ownDataField(use, 'lane');
+    return {
+        supply: supply === undefined ? 'content_text' : supply === 'content_text' || supply === 'path' ? supply : undefined,
+        lane: lane === 'objective' || lane === 'steer' ? lane : undefined,
+        card: scenarioSupplyReadingOf(ownDataField(use, 'scenario')),
+    };
+}
+export function userAttachmentSeatAdmits(reading, use) {
     try {
         if (!isPlainRecord(reading))
             return 'unknown';
@@ -58,16 +86,25 @@ export function userAttachmentSeatAdmits(reading) {
             return 'no';
         if (kind !== 'present')
             return 'unknown';
+        const q = seatQuestionOf(use);
+        if (q === undefined)
+            return 'unknown';
         const has = (key, word) => {
             const list = stringList(readOwnDataValue(reading, key));
-            return list === undefined ? undefined : list.includes(word);
+            return list === undefined ? undefined : word !== undefined && list.includes(word);
         };
-        const objective = has('entries', 'objective');
-        const text = has('supplies', 'content_text');
-        const client = has('kinds', 'client_text');
-        if (objective === undefined || text === undefined || client === undefined)
+        const lane = has('entries', q.lane);
+        const supply = has('supplies', q.supply);
+        const client = q.supply === 'path' ? true : has('kinds', 'client_text');
+        if (lane === undefined || supply === undefined || client === undefined)
+            return 'unknown';
+        if (!(lane && supply && client))
+            return 'no';
+        if (q.card === 'unreadable')
             return 'unknown';
-        return objective && text && client ? 'yes' : 'no';
+        if (q.card === 'not_handed' || q.card === 'not_on_card')
+            return q.supply === 'path' ? 'unknown' : 'yes';
+        return q.supply !== undefined && q.card.includes(q.supply) ? 'yes' : 'no';
     }
     catch {
         return 'unknown';

package/dist/wiringInstructionsAttribution.js

@@ -1,6 +1,7 @@
 import { callerCwdAdmitted } from './callerCwdCapability.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { readOutboundBodyField } from './fileHistoryLegNotice.js';
+import { pathShapeOf } from './pathShape.js';
 export function legCwdOfBody(body, callerCwd) {
     if (!callerCwdAdmitted(callerCwd))
         return undefined;
@@ -23,9 +24,10 @@ function safeRelativeMember(member) {
         return false;
     if (displayUntrusted(member) !== member)
         return false;
-    if (member.includes('\\') || member.startsWith('/') || /^[A-Za-z]:/.test(member))
+    if (member.includes('\\') || /^[A-Za-z]:/.test(member))
         return false;
-    return member.split('/').every((seg) => seg !== '' && seg !== '..');
+    const shape = pathShapeOf(member);
+    return shape !== undefined && shape.kind === 'relative' && !shape.hasEmptySegment && !shape.hasTrailingSeparator && !shape.hasParentSegment;
 }
 function isSep(path, c) {
     return c === '/' || (!path.startsWith('/') && c === '\\');
@@ -37,6 +39,10 @@ function trimSeps(path) {
     return path.slice(0, end);
 }
 function strictlyWithin(child, dir) {
+    const c = pathShapeOf(child);
+    const d = pathShapeOf(dir);
+    if (c === undefined || d === undefined || c.hasDotSegment || d.hasDotSegment)
+        return false;
     const trimmed = trimSeps(dir);
     if (!child.startsWith(trimmed) || child.length <= trimmed.length)
         return false;