@sema-agent/client-core 0.109.0 → 0.110.0

package/dist/subagent/engineSubagentTail.js

@@ -7,6 +7,7 @@ import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { readFrameTrueMark } from '../ownKey.js';
+import { publishEngineInlineTaskModel } from '../engineInlineTaskStats.js';
 function usableTailClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
 }
@@ -149,6 +150,11 @@ export function tailEngineSubagent(taskId, opts) {
                     hostLog('debug', `[subagent-tail] ${taskId} settled (${String(d.status)}${typeof d.seq === 'number' ? ` seq=${d.seq}` : ''}${typeof d.summary === 'string' ? ` summary=${d.summary.slice(0, 80)}` : ''}) — close`);
                     break;
                 }
+                else if (t === 'task_progress' || t === 'task_started') {
+                    const card = parentToolCallIdOf(taskId);
+                    if (card !== undefined && card !== taskId && typeof d.model === 'string')
+                        publishEngineInlineTaskModel(card, d.model);
+                }
             }
         }
         catch (e) {

package/dist/terminalStatuses.d.ts

@@ -26,6 +26,7 @@ export type CoreSemaTaskTerminalStatus = (typeof CORE_SEMA_TASK_TERMINAL_STATUSE
 export declare function isCoreSemaTaskTerminal(status: unknown): status is CoreSemaTaskTerminalStatus;
 export declare const CORE_WORKFLOW_RUN_TERMINAL_STATUSES: readonly ["completed", "failed"];
 export declare function isCoreWorkflowRunTerminal(status: unknown): status is (typeof CORE_WORKFLOW_RUN_TERMINAL_STATUSES)[number];
+export declare function isCoreWorkflowRunParkedEnd(status: unknown, errorCode: unknown): boolean;
 export declare const CORE_TASK_PROGRESS_TERMINAL_STATUSES: readonly ["completed", "failed"];
 export declare function isCoreTaskProgressTerminal(status: unknown): status is (typeof CORE_TASK_PROGRESS_TERMINAL_STATUSES)[number];
 export declare function isCoreTaskProgressTerminalNotSuccess(status: unknown): status is 'failed';

package/dist/terminalStatuses.js

@@ -1,4 +1,4 @@
-import { CORE_TERMINAL_CAUSE_KINDS, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES as GENERATED_TASK_NOTIFICATION_TERMINAL_STATUSES } from './generated/engineFactTables.js';
+import { CORE_TERMINAL_CAUSE_KINDS, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES as GENERATED_TASK_NOTIFICATION_TERMINAL_STATUSES, CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE, } from './generated/engineFactTables.js';
 function memberOf(table, word) {
     return typeof word === 'string' && table.includes(word);
 }
@@ -53,6 +53,9 @@ export const CORE_WORKFLOW_RUN_TERMINAL_STATUSES = Object.freeze(['completed', '
 export function isCoreWorkflowRunTerminal(status) {
     return memberOf(CORE_WORKFLOW_RUN_TERMINAL_STATUSES, status);
 }
+export function isCoreWorkflowRunParkedEnd(status, errorCode) {
+    return status === 'failed' && errorCode === CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE;
+}
 export const CORE_TASK_PROGRESS_TERMINAL_STATUSES = Object.freeze(['completed', 'failed']);
 export function isCoreTaskProgressTerminal(status) {
     return memberOf(CORE_TASK_PROGRESS_TERMINAL_STATUSES, status);

package/dist/turnFailurePresentation.js

@@ -1,6 +1,6 @@
 import { msg, renderMessage } from './i18n/translate.js';
 import { classifyTurnWireError, isPreStreamDrainingReject } from './wireErrorTriage.js';
-import { isSseIdleError } from './sseIdleTriage.js';
+import { isSseIdleError, streamEndedReasonOf } from './sseIdleTriage.js';
 import { runNotFollowedOf } from './runFollow.js';
 import { isCodeClassifiedGateFailure } from './gateFailureCodes.js';
 import { CORRUPT_ROW_ERROR_CODE, CORRUPT_SESSION_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
@@ -36,6 +36,13 @@ const TURN_FAILURE_HEADLINE_KEYS = Object.freeze({
     internal: 'notice.failure.headline.internal',
     cause_unreadable: 'notice.failure.headline.causeUnreadable',
 });
+const STREAM_ENDED_HEADLINE_KEYS = Object.freeze({
+    empty_legs: 'notice.streamEnded.emptyLegs.headline',
+    consecutive_failures: 'notice.streamEnded.consecutiveFailures.headline',
+});
+function parkedHeadlineKeyOf(reading) {
+    return reading.kind === 'read' ? STREAM_ENDED_HEADLINE_KEYS[reading.reason] : TURN_FAILURE_HEADLINE_KEYS.parked;
+}
 function waitSecOf(err) {
     const ms = readThrownSlot(err, 'retryAfterMs', 'data');
     if (typeof ms === 'number' && Number.isFinite(ms) && ms > 0)
@@ -128,7 +135,7 @@ export function turnFailurePresentation(err, evidence, notesCtx, lang) {
     }
     else if (verdict.kind === 'stream-ended-without-terminal') {
         shape = { category: 'parked', offer: false };
-        headlineKey = TURN_FAILURE_HEADLINE_KEYS.parked;
+        headlineKey = parkedHeadlineKeyOf(streamEndedReasonOf(err));
         detail = wireFailureTextsOf(err).reason;
     }
     else if (verdict.kind === 'transport') {

package/dist/typePins.d.ts

@@ -8,4 +8,15 @@ type WritableKeys<T> = {
     }, P, never>;
 }[keyof T];
 export type AllReadonly<T> = [WritableKeys<T>] extends [never] ? true : false;
+export type Same<A, B> = [Exclude<A, B>, Exclude<B, A>] extends [never, never] ? true : false;
+export type KeysEq<A, B> = Same<keyof A, keyof B>;
+export type Fits<A, B> = [A] extends [B] ? true : false;
+export type Present<T> = [T] extends [never] ? false : true;
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+export type NeverValuedKeys<T> = {
+    [K in keyof T]-?: [Exclude<T[K], undefined>] extends [never] ? K : never;
+}[keyof T];
+export type NoNeverValues<T> = Same<NeverValuedKeys<T>, never>;
 export {};

package/dist/usageAnalytics.d.ts

@@ -144,3 +144,20 @@ export declare function projectUsageAnalytics(inputs: UsageAnalyticsInputs, wind
 export declare function readUsageAnalytics(client: UsageAnalyticsClientLike, window: UsageAnalyticsWindow, opts?: {
     signal?: AbortSignal;
 }): Promise<UsageAnalyticsView>;
+export declare const CENTER_USAGE_COST_UNKNOWN_WHYS: readonly ["declared_unknown", "basis_unrecognized", "estimated_zero", "amount_absent"];
+export type CenterUsageCostUnknownWhy = (typeof CENTER_USAGE_COST_UNKNOWN_WHYS)[number];
+export interface CenterUsageCostAmount {
+    readonly value: number;
+    readonly bound: Extract<UsageBound, 'exact' | 'lower'>;
+}
+export interface CenterUsageCostAmountReading {
+    readonly state: 'amount';
+    readonly amount: CenterUsageCostAmount;
+    readonly unpriced: boolean;
+}
+export interface CenterUsageCostUnknownReading {
+    readonly state: 'unknown';
+    readonly why: CenterUsageCostUnknownWhy;
+}
+export type CenterUsageCostReading = CenterUsageCostAmountReading | CenterUsageCostUnknownReading;
+export declare function centerUsageCostOf(body: object | null | undefined): CenterUsageCostReading;

package/dist/usageAnalytics.js

@@ -1,4 +1,4 @@
-import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+import { readThrownSlot, slotReadOf, THROWN_SLOT_UNREADABLE } from './wireFailureShape.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.',
@@ -161,6 +161,9 @@ export function readUsageBreakdown(client, opts = {}) {
 export function usageBoundPrefix(bound) {
     return bound === 'lower' ? '≥' : bound === 'approximate' ? '≈' : '';
 }
+function costBoundOf(precision, truncated) {
+    return precision === 'exact' && !truncated ? 'exact' : 'lower';
+}
 const DAY_MS = 86_400_000;
 export const USAGE_HEATMAP_MAX_DAYS = 70;
 export function usageWindowOfRange(range, now) {
@@ -275,7 +278,7 @@ export function projectUsageAnalytics(inputs, window) {
         readings.tokens = { value: sv.tokensIn + sv.tokensOut, bound: !exact ? 'approximate' : sv.truncated ? 'lower' : 'exact' };
     }
     if (sv.cost !== undefined)
-        readings.cost = { value: sv.cost, bound: exact && !sv.truncated ? 'exact' : 'lower' };
+        readings.cost = { value: sv.cost, bound: costBoundOf(sv.precision, sv.truncated) };
     const day = inputs.daySeries;
     if (day.kind === 'ok' && isWhole(day.value)) {
         const dayValues = new Map();
@@ -328,3 +331,42 @@ export async function readUsageAnalytics(client, window, opts = {}) {
     ]);
     return projectUsageAnalytics({ summary, daySeries, hourSeries, modelBreakdown }, window);
 }
+const CENTER_COST_BASIS_WORDS = ['exact', 'lowerBound', 'unknown'];
+export const CENTER_USAGE_COST_UNKNOWN_WHYS = Object.freeze(['declared_unknown', 'basis_unrecognized', 'estimated_zero', 'amount_absent']);
+const unknownCost = (why) => ({ state: 'unknown', why });
+const amountCost = (value, bound, unpriced) => ({ state: 'amount', amount: { value, bound }, unpriced });
+const flagNotRuledOut = (r) => r.value === true || r.presence === 'unreadable';
+export function centerUsageCostOf(body) {
+    try {
+        if (!isRecord(body))
+            return unknownCost('amount_absent');
+        const basis = slotReadOf(body, 'costBasis');
+        let word;
+        if (basis.presence === 'present') {
+            word = CENTER_COST_BASIS_WORDS.find((w) => w === basis.value);
+            if (word === undefined)
+                return unknownCost('basis_unrecognized');
+        }
+        else if (basis.presence === 'unreadable') {
+            return unknownCost('basis_unrecognized');
+        }
+        if (word === 'unknown')
+            return unknownCost('declared_unknown');
+        const cost = slotReadOf(body, 'costUsd').value;
+        if (!nonNeg(cost))
+            return unknownCost('amount_absent');
+        const est = slotReadOf(body, 'estimated');
+        const trunc = slotReadOf(body, 'truncated');
+        const unpriced = est.value === true;
+        if (word === 'lowerBound')
+            return amountCost(cost, 'lower', unpriced);
+        if (word === 'exact')
+            return flagNotRuledOut(est) || flagNotRuledOut(trunc) ? amountCost(cost, 'lower', unpriced) : amountCost(cost, 'exact', false);
+        if (unpriced && cost === 0)
+            return unknownCost('estimated_zero');
+        return amountCost(cost, costBoundOf(precisionOf(est.value), flagNotRuledOut(trunc)), unpriced);
+    }
+    catch {
+        return unknownCost('amount_absent');
+    }
+}

package/dist/wireFailureShape.d.ts

@@ -24,7 +24,6 @@ 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;
@@ -32,6 +31,7 @@ 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 +47,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

@@ -91,39 +91,39 @@ 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 { sdkInstance, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     }
-    return { sdkInstance, bag: { state: 'object', value: slot } };
+    return { 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 +139,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' };
     }

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 {
@@ -158,6 +159,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;

package/dist/wireRefusalCopy.js

@@ -877,6 +877,74 @@ export function sessionIdRetiredFromError(err) {
 export function sessionIdRetiredContent(detail, lang) {
     return renderMessage(msg(detail.folded === true ? 'notice.wireRefusal.sessionIdRetired.folded' : 'notice.wireRefusal.sessionIdRetired'), lang);
 }
+function isIndexedMemberCoordinate(field, list, member) {
+    const head = `${list}[`;
+    if (!field.startsWith(head))
+        return false;
+    const close = field.indexOf(']', head.length);
+    if (close < 0 || !/^[0-9]+$/.test(field.slice(head.length, close)))
+        return false;
+    const rest = field.slice(close + 1);
+    return rest === `.${member}` || rest.startsWith(`.${member}.`);
+}
+function unreadMembersFaceOf(field) {
+    if (/^settings\.hooks(?:\.|$)/.test(field))
+        return 'settings_hooks';
+    if (/^settings\.env(?:\.|$)/.test(field))
+        return 'settings_env';
+    if (/^settings\.[^\s.[\]]/.test(field))
+        return 'settings_other';
+    if (isIndexedMemberCoordinate(field, 'mcpServers', 'transport'))
+        return 'mcp_transport';
+    if (isIndexedMemberCoordinate(field, 'a2aPeers', 'headers'))
+        return 'a2a_headers';
+    return undefined;
+}
+export function unreadRequestMembersFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== FIELD_INVALID)
+            return null;
+        const slots = readRefusalSlots(err, ['field', 'reason', 'detail']);
+        if (slots.reason.present || slots.detail.present)
+            return null;
+        const field = slots.field.word;
+        if (field === undefined)
+            return null;
+        const face = unreadMembersFaceOf(field);
+        if (face === undefined)
+            return null;
+        return Object.freeze({ code: FIELD_INVALID, field, face, ...(effective.folded ? { folded: true } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+function unreadMembersPartKey(face) {
+    switch (face) {
+        case 'settings_hooks':
+            return 'notice.wireRefusal.unreadMembers.part.settingsHooks';
+        case 'settings_env':
+            return 'notice.wireRefusal.unreadMembers.part.settingsEnv';
+        case 'settings_other':
+            return 'notice.wireRefusal.unreadMembers.part.settingsOther';
+        case 'mcp_transport':
+            return 'notice.wireRefusal.unreadMembers.part.mcpTransport';
+        case 'a2a_headers':
+            return 'notice.wireRefusal.unreadMembers.part.a2aHeaders';
+    }
+}
+const UNREAD_MEMBERS_FIELD_SHOWN_MAX = 120;
+export function unreadRequestMembersContent(detail, lang) {
+    const folded = detail.folded === true;
+    const part = renderMessage(msg(unreadMembersPartKey(detail.face)), lang);
+    const head = renderMessage(msg(folded ? 'notice.wireRefusal.unreadMembers.folded' : 'notice.wireRefusal.unreadMembers', { part }), lang);
+    const quoted = quoteUntrustedForSentence(detail.field, UNREAD_MEMBERS_FIELD_SHOWN_MAX);
+    const where = quoted !== undefined ? ` · ${renderMessage(msg('notice.wireRefusal.unreadMembers.where', { where: quoted }), lang)}` : '';
+    return `${head}${where} · ${renderMessage(msg(folded ? 'notice.wireRefusal.unreadMembers.folded.remedy' : 'notice.wireRefusal.unreadMembers.remedy'), lang)}`;
+}
 export function runConcurrencyCapFromError(err) {
     try {
         if (typeof err !== 'object' || err === null)
@@ -1069,3 +1137,11 @@ export function userAttachmentRefusalFromError(err) {
 export function userInvokedSkillRefusalFromError(err) {
     return effectiveWireErrorCode(err) === USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE ? { code: USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, retryable: false } : null;
 }
+const _pinRequestField = [true, true, true, true, true, true, true, true];
+void _pinRequestField;
+const _pinSettingsHooks = [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true];
+void _pinSettingsHooks;
+const _pinAttachment = [true, true, true];
+void _pinAttachment;
+const _pinWallSource = [true, true, true];
+void _pinWallSource;